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

package/cjs/classes/winston.logger.class.js

@@ -2,9 +2,17 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "instance", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get createModuleLogger () {
+        return createModuleLogger;
+    },
+    get instance () {
         return instance;
     }
 });
@@ -12,8 +20,8 @@ const _config = require("@flusys/nestjs-core/config");
 const _fs = require("fs");
 const _path = require("path");
 const _winston = require("winston");
-const _winstontransport = /*#__PURE__*/ _interop_require_wildcard(require("winston-transport"));
 const _winstondailyrotatefile = /*#__PURE__*/ _interop_require_wildcard(require("winston-daily-rotate-file"));
+const _winstontransport = /*#__PURE__*/ _interop_require_wildcard(require("winston-transport"));
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -85,33 +93,48 @@ if (!(0, _fs.existsSync)(LOG_DIR)) {
 }
 // Custom Formats
 /**
- * Custom format for structured logging
- * Includes: timestamp, level, context, requestId, userId, message, metadata
- */ const structuredFormat = _winston.format.printf(({ timestamp, level, message, context, requestId, userId, stack, ...metadata })=>{
-    const logEntry = {
-        timestamp,
-        level: level.toUpperCase(),
-        context: context || 'App',
-        message
-    };
-    if (requestId) logEntry.requestId = requestId;
-    if (userId) logEntry.userId = userId;
-    if (Object.keys(metadata).length > 0) logEntry.metadata = metadata;
-    if (stack) logEntry.stack = stack;
-    return JSON.stringify(logEntry);
-});
-/**
- * Custom format for development console output
- * Human-readable format with colors
- */ const devConsoleFormat = _winston.format.printf(({ timestamp, level, message, context, requestId, userId, method, url, path, statusCode, duration, stack })=>{
-    const ctx = context || 'App';
-    const reqId = requestId ? ` [${requestId}]` : '';
-    const user = userId ? ` (user:${userId})` : '';
-    const endpoint = method && (path || url) ? ` [${method} ${path || url}]` : '';
-    const status = statusCode ? ` [${statusCode}]` : '';
-    const time = duration ? ` (${duration})` : '';
-    const stackTrace = stack ? `\n${stack}` : '';
-    return `${timestamp} [${level.toUpperCase().padEnd(7)}] [${ctx}]${endpoint}${status}${time}${reqId}${user} ${message}${stackTrace}`;
+ * Custom format for structured logging (production)
+ * Multi-line format:
+ * - Line 1: Timestamp
+ * - Line 2: Log Level
+ * - Line 3: [RequestId]
+ * - Line 4: Empty
+ * - Line 5+: Message with context
+ */ const LEVEL_MAP = {
+    error: 'Error',
+    warn: 'Warning',
+    info: 'Information',
+    debug: 'Debug',
+    verbose: 'Verbose'
+};
+const LOG_SEPARATOR = '─'.repeat(80);
+const structuredFormat = _winston.format.printf(({ timestamp, level, message, context, requestId, userId, tenantId, companyId, method, url, path, statusCode, duration, stack, ...metadata })=>{
+    const reqId = requestId || 'no-request-id';
+    const levelFormatted = LEVEL_MAP[level] || level.charAt(0).toUpperCase() + level.slice(1);
+    const contextParts = [];
+    if (context) contextParts.push(`Context: ${context}`);
+    if (method && (path || url)) contextParts.push(`Endpoint: ${method} ${path || url}`);
+    if (statusCode) contextParts.push(`Status: ${statusCode}`);
+    if (duration) contextParts.push(`Duration: ${duration}`);
+    if (userId) contextParts.push(`UserId: ${userId}`);
+    if (tenantId) contextParts.push(`TenantId: ${tenantId}`);
+    if (companyId) contextParts.push(`CompanyId: ${companyId}`);
+    let content = message;
+    if (contextParts.length > 0) {
+        content = `${contextParts.join(' | ')}\n${message}`;
+    }
+    const metaKeys = Object.keys(metadata).filter((k)=>k !== 'splat');
+    if (metaKeys.length > 0) {
+        const metaStr = JSON.stringify(metaKeys.reduce((acc, k)=>({
+                ...acc,
+                [k]: metadata[k]
+            }), {}));
+        content += `\nMetadata: ${metaStr}`;
+    }
+    if (stack) {
+        content += `\nStack: ${stack}`;
+    }
+    return `${LOG_SEPARATOR}\n${timestamp} | ${levelFormatted} | [${reqId}]\n${content}`;
 });
 // Transports
 /**
@@ -134,63 +157,44 @@ if (!(0, _fs.existsSync)(LOG_DIR)) {
     maxFiles: LOG_MAX_FILES,
     level: 'error'
 });
-// Tenant-Aware Transport
-/**
- * Cache for tenant-specific transports
- * Avoids creating new transport instances for each log entry
- */ const tenantTransportCache = new Map();
-/**
- * Get or create a tenant-specific transport
- * Creates logs in: logs/{tenantId}/combined-YYYY-MM-DD.log
- */ function getTenantTransport(tenantId) {
-    if (tenantTransportCache.has(tenantId)) {
-        return tenantTransportCache.get(tenantId);
-    }
-    const tenantLogDir = (0, _path.join)(LOG_DIR, tenantId);
-    if (!(0, _fs.existsSync)(tenantLogDir)) {
-        (0, _fs.mkdirSync)(tenantLogDir, {
+// Transport Caches
+const moduleTransportCache = new Map();
+const tenantTransportCache = new Map();
+function getCachedTransport(cache, name) {
+    const cached = cache.get(name);
+    if (cached) return cached;
+    const logDir = (0, _path.join)(LOG_DIR, name);
+    if (!(0, _fs.existsSync)(logDir)) {
+        (0, _fs.mkdirSync)(logDir, {
             recursive: true
         });
     }
     const transport = new DailyRotateFile({
-        filename: `${tenantLogDir}/combined-%DATE%.log`,
+        filename: `${logDir}/combined-%DATE%.log`,
         datePattern: 'YYYY-MM-DD',
         zippedArchive: true,
         maxSize: LOG_MAX_SIZE,
         maxFiles: LOG_MAX_FILES,
         level: LOG_LEVEL
     });
-    tenantTransportCache.set(tenantId, transport);
+    cache.set(name, transport);
     return transport;
 }
-/**
- * Tenant-aware transport wrapper
- * Routes logs to tenant-specific folders when tenantId is present
- */ let TenantAwareTransport = class TenantAwareTransport extends Transport {
+const getModuleTransport = (name)=>getCachedTransport(moduleTransportCache, name);
+const getTenantTransport = (name)=>getCachedTransport(tenantTransportCache, name);
+let TenantAwareTransport = class TenantAwareTransport extends Transport {
     log(info, callback) {
         setImmediate(()=>this.emit('logged', info));
         const tenantId = info.tenantId || info.metadata?.tenantId;
-        if (USE_TENANT_MODE && tenantId) {
-            // Write to tenant-specific folder
-            const tenantTransport = getTenantTransport(tenantId);
-            tenantTransport.log(info, callback);
-        } else {
-            // Write to default log folder
-            this.defaultTransport.log(info, callback);
-        }
+        const transport = USE_TENANT_MODE && tenantId ? getTenantTransport(tenantId) : this.defaultTransport;
+        transport.log(info, callback);
     }
     constructor(defaultTransport){
-        super(), _define_property(this, "defaultTransport", void 0);
-        this.defaultTransport = defaultTransport;
+        super(), _define_property(this, "defaultTransport", void 0), this.defaultTransport = defaultTransport;
     }
 };
-/**
- * Tenant-aware combined transport
- * When USE_TENANT_MODE=true, routes to tenant folders (like database mode)
- */ const tenantAwareCombinedTransport = new TenantAwareTransport(combinedRotateTransport);
-/**
- * Console transport for development
- */ const consoleTransport = new _winston.transports.Console({
+const tenantAwareCombinedTransport = new TenantAwareTransport(combinedRotateTransport);
+const consoleTransport = new _winston.transports.Console({
     level: LOG_LEVEL,
     format: _winston.format.combine(_winston.format.colorize({
         all: true
@@ -198,7 +202,7 @@ if (!(0, _fs.existsSync)(LOG_DIR)) {
         format: 'YYYY-MM-DD HH:mm:ss'
     }), _winston.format.errors({
         stack: true
-    }), devConsoleFormat)
+    }), structuredFormat)
 });
 // Logger Instances
 /**
@@ -239,3 +243,32 @@ if (!(0, _fs.existsSync)(LOG_DIR)) {
     exitOnError: false
 });
 const instance = _config.envConfig.isProduction() ? prodLogger : devLogger;
+/**
+ * Module logger cache to avoid creating multiple loggers for the same module
+ */ const moduleLoggerCache = new Map();
+function createModuleLogger(moduleName) {
+    // In dev mode, use global console logger
+    if (!_config.envConfig.isProduction()) {
+        return devLogger;
+    }
+    // Check cache first
+    if (moduleLoggerCache.has(moduleName)) {
+        return moduleLoggerCache.get(moduleName);
+    }
+    // Create module-specific logger for production
+    const moduleLogger = (0, _winston.createLogger)({
+        level: LOG_LEVEL,
+        format: _winston.format.combine(_winston.format.timestamp({
+            format: 'YYYY-MM-DD HH:mm:ss.SSS'
+        }), _winston.format.errors({
+            stack: true
+        }), structuredFormat),
+        transports: [
+            getModuleTransport(moduleName),
+            errorRotateTransport
+        ],
+        exitOnError: false
+    });
+    moduleLoggerCache.set(moduleName, moduleLogger);
+    return moduleLogger;
+}

package/cjs/constants/index.js

@@ -25,9 +25,6 @@ _export(exports, {
     get IS_PUBLIC_KEY () {
         return IS_PUBLIC_KEY;
     },
-    get LOGGER_INSTANCE () {
-        return LOGGER_INSTANCE;
-    },
     get PERMISSIONS_CACHE_PREFIX () {
         return PERMISSIONS_CACHE_PREFIX;
     },
@@ -42,6 +39,7 @@ _export(exports, {
     }
 });
 _export_star(require("./permissions"), exports);
+_export_star(require("./message-keys"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
@@ -59,7 +57,6 @@ const IS_PUBLIC_KEY = 'isPublic';
 const PERMISSIONS_KEY = 'permissions';
 const CACHE_INSTANCE = 'CACHE_INSTANCE';
 const PERMISSION_GUARD_CONFIG = 'PERMISSION_GUARD_CONFIG';
-const LOGGER_INSTANCE = 'LOGGER_INSTANCE';
 const IDEMPOTENCY_KEY_HEADER = 'x-idempotency-key';
 const REQUEST_ID_HEADER = 'x-request-id';
 const CLIENT_TYPE_HEADER = 'x-client-type';

package/cjs/constants/message-keys.js

@@ -0,0 +1,68 @@
+// ==================== AUTH (Shared across guards/interceptors) ====================
+// These are duplicated in nestjs-auth but needed here to avoid circular dependencies
+"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 AUTH_MESSAGES () {
+        return AUTH_MESSAGES;
+    },
+    get ERROR_MESSAGES () {
+        return ERROR_MESSAGES;
+    },
+    get SYSTEM_MESSAGES () {
+        return SYSTEM_MESSAGES;
+    }
+});
+const AUTH_MESSAGES = {
+    TOKEN_REQUIRED: 'auth.token.required',
+    TOKEN_INVALID: 'auth.token.invalid',
+    ENTITY_BELOG_ANOTHER_COMPANY: 'entity.belongs.another.company',
+    COMPANY_NO_ACCESS: 'auth.company.no.access'
+};
+const ERROR_MESSAGES = {
+    NOT_FOUND: 'error.not.found',
+    VALIDATION: 'error.validation',
+    UNAUTHORIZED: 'error.unauthorized',
+    FORBIDDEN: 'error.forbidden',
+    CONFLICT: 'error.conflict',
+    DB_FOREIGN_KEY: 'error.db.foreign.key',
+    DB_NOT_NULL: 'error.db.not.null',
+    DB_INVALID_INPUT: 'error.db.invalid.input',
+    DB_VALUE_TOO_LONG: 'error.db.value.too.long',
+    DB_CHECK_CONSTRAINT: 'error.db.check.constraint',
+    DB_DEADLOCK: 'error.db.deadlock',
+    INTERNAL: 'error.internal',
+    SERVICE_UNAVAILABLE: 'error.service.unavailable',
+    UNKNOWN: 'error.unknown',
+    HTTP: 'error.http',
+    GENERIC: 'error.generic',
+    PERMISSION_SYSTEM_UNAVAILABLE: 'error.permission.system.unavailable',
+    INSUFFICIENT_PERMISSIONS: 'error.insufficient.permissions',
+    INSUFFICIENT_PERMISSIONS_OR: 'error.insufficient.permissions.or',
+    NO_PERMISSIONS_FOUND: 'error.no.permissions.found',
+    ENDPOINT_DISABLED: 'error.endpoint.disabled'
+};
+const SYSTEM_MESSAGES = {
+    REPOSITORY_NOT_AVAILABLE: 'system.repository.not.available',
+    DATASOURCE_NOT_AVAILABLE: 'system.datasource.not.available',
+    DATABASE_CONFIG_NOT_AVAILABLE: 'system.database.config.not.available',
+    SERVICE_NOT_AVAILABLE: 'system.service.not.available',
+    CONFIG_REQUIRED: 'system.config.required',
+    INTERNAL_ERROR: 'system.internal.error',
+    DUPLICATE_REQUEST: 'system.duplicate.request',
+    INVALID_TENANT_ID: 'system.invalid.tenant.id',
+    TENANT_NOT_FOUND: 'system.tenant.not.found',
+    TENANT_HEADER_REQUIRED: 'system.tenant.header.required',
+    MISSING_PARAMETER: 'system.missing.parameter',
+    SDK_NOT_INSTALLED: 'system.sdk.not.installed',
+    PATH_TRAVERSAL_DETECTED: 'system.path.traversal.detected',
+    INVALID_FILE_KEY: 'system.invalid.file.key'
+};

package/cjs/constants/permissions.js

@@ -1,13 +1,4 @@
-/**
- * Centralized Permission Codes
- *
- * Single source of truth for all permission codes used across the application.
- * Use these constants instead of hardcoded strings to prevent typos and enable easy refactoring.
- *
- * Naming Convention: <entity>.<action>
- * - entity: The resource being accessed (e.g., user, role, company)
- * - action: The operation being performed (create, read, update, delete, assign)
- */ // ==================== AUTH MODULE ====================
+// ==================== AUTH MODULE ====================
 "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
@@ -37,6 +28,9 @@ _export(exports, {
     get EMAIL_TEMPLATE_PERMISSIONS () {
         return EMAIL_TEMPLATE_PERMISSIONS;
     },
+    get EVENT_PERMISSIONS () {
+        return EVENT_PERMISSIONS;
+    },
     get FILE_PERMISSIONS () {
         return FILE_PERMISSIONS;
     },
@@ -49,6 +43,12 @@ _export(exports, {
     get FORM_RESULT_PERMISSIONS () {
         return FORM_RESULT_PERMISSIONS;
     },
+    get LANGUAGE_PERMISSIONS () {
+        return LANGUAGE_PERMISSIONS;
+    },
+    get NOTIFICATION_PERMISSIONS () {
+        return NOTIFICATION_PERMISSIONS;
+    },
     get PERMISSIONS () {
         return PERMISSIONS;
     },
@@ -61,6 +61,30 @@ _export(exports, {
     get STORAGE_CONFIG_PERMISSIONS () {
         return STORAGE_CONFIG_PERMISSIONS;
     },
+    get TASK_BOARD_PERMISSIONS () {
+        return TASK_BOARD_PERMISSIONS;
+    },
+    get TASK_COMMENT_PERMISSIONS () {
+        return TASK_COMMENT_PERMISSIONS;
+    },
+    get TASK_LABEL_PERMISSIONS () {
+        return TASK_LABEL_PERMISSIONS;
+    },
+    get TASK_LIST_PERMISSIONS () {
+        return TASK_LIST_PERMISSIONS;
+    },
+    get TASK_PERMISSIONS () {
+        return TASK_PERMISSIONS;
+    },
+    get TRANSLATION_KEY_PERMISSIONS () {
+        return TRANSLATION_KEY_PERMISSIONS;
+    },
+    get TRANSLATION_PERMISSIONS () {
+        return TRANSLATION_PERMISSIONS;
+    },
+    get UPLOAD_CONFIG_PERMISSIONS () {
+        return UPLOAD_CONFIG_PERMISSIONS;
+    },
     get USER_ACTION_PERMISSIONS () {
         return USER_ACTION_PERMISSIONS;
     },
@@ -135,6 +159,9 @@ const STORAGE_CONFIG_PERMISSIONS = {
     UPDATE: 'storage-config.update',
     DELETE: 'storage-config.delete'
 };
+const UPLOAD_CONFIG_PERMISSIONS = {
+    DELETE: 'upload-config.delete'
+};
 const EMAIL_CONFIG_PERMISSIONS = {
     CREATE: 'email-config.create',
     READ: 'email-config.read',
@@ -159,6 +186,68 @@ const FORM_RESULT_PERMISSIONS = {
     UPDATE: 'form-result.update',
     DELETE: 'form-result.delete'
 };
+const EVENT_PERMISSIONS = {
+    CREATE: 'event.create',
+    READ: 'event.read',
+    UPDATE: 'event.update',
+    DELETE: 'event.delete'
+};
+const NOTIFICATION_PERMISSIONS = {
+    CREATE: 'notification.create',
+    READ: 'notification.read',
+    UPDATE: 'notification.update',
+    DELETE: 'notification.delete'
+};
+const LANGUAGE_PERMISSIONS = {
+    CREATE: 'language.create',
+    READ: 'language.read',
+    UPDATE: 'language.update',
+    DELETE: 'language.delete'
+};
+const TRANSLATION_KEY_PERMISSIONS = {
+    CREATE: 'translation-key.create',
+    READ: 'translation-key.read',
+    UPDATE: 'translation-key.update',
+    DELETE: 'translation-key.delete'
+};
+const TRANSLATION_PERMISSIONS = {
+    CREATE: 'translation.create',
+    READ: 'translation.read',
+    UPDATE: 'translation.update',
+    DELETE: 'translation.delete'
+};
+const TASK_BOARD_PERMISSIONS = {
+    CREATE: 'task-board.create',
+    READ: 'task-board.read',
+    UPDATE: 'task-board.update',
+    DELETE: 'task-board.delete',
+    MANAGE_MEMBERS: 'task-board.manage-members'
+};
+const TASK_LIST_PERMISSIONS = {
+    CREATE: 'task-list.create',
+    READ: 'task-list.read',
+    UPDATE: 'task-list.update',
+    DELETE: 'task-list.delete'
+};
+const TASK_PERMISSIONS = {
+    CREATE: 'task.create',
+    READ: 'task.read',
+    UPDATE: 'task.update',
+    DELETE: 'task.delete',
+    MOVE: 'task.move',
+    ASSIGN: 'task.assign'
+};
+const TASK_LABEL_PERMISSIONS = {
+    CREATE: 'task-label.create',
+    READ: 'task-label.read',
+    UPDATE: 'task-label.update',
+    DELETE: 'task-label.delete'
+};
+const TASK_COMMENT_PERMISSIONS = {
+    CREATE: 'task-comment.create',
+    READ: 'task-comment.read',
+    DELETE: 'task-comment.delete'
+};
 const PERMISSIONS = {
     // Auth
     USER: USER_PERMISSIONS,
@@ -180,5 +269,19 @@ const PERMISSIONS = {
     EMAIL_TEMPLATE: EMAIL_TEMPLATE_PERMISSIONS,
     // Form Builder
     FORM: FORM_PERMISSIONS,
-    FORM_RESULT: FORM_RESULT_PERMISSIONS
+    FORM_RESULT: FORM_RESULT_PERMISSIONS,
+    // Event Manager
+    EVENT: EVENT_PERMISSIONS,
+    // Notification
+    NOTIFICATION: NOTIFICATION_PERMISSIONS,
+    // Localization
+    LANGUAGE: LANGUAGE_PERMISSIONS,
+    TRANSLATION_KEY: TRANSLATION_KEY_PERMISSIONS,
+    TRANSLATION: TRANSLATION_PERMISSIONS,
+    // Task Manager
+    TASK_BOARD: TASK_BOARD_PERMISSIONS,
+    TASK_LIST: TASK_LIST_PERMISSIONS,
+    TASK: TASK_PERMISSIONS,
+    TASK_LABEL: TASK_LABEL_PERMISSIONS,
+    TASK_COMMENT: TASK_COMMENT_PERMISSIONS
 };

package/cjs/decorators/api-response.decorator.js

@@ -12,10 +12,9 @@ const _dtos = require("../dtos");
 const _common = require("@nestjs/common");
 const _swagger = require("@nestjs/swagger");
 const ApiResponseDto = (dto, isArray = false, arrayType = 'list')=>{
-    // Select appropriate wrapper based on response type
     let wrapperDto;
     let metaDto = null;
-    if (!isArray) {
+    if (!isArray || arrayType === 'single') {
         wrapperDto = _dtos.SingleResponseDto;
     } else if (arrayType === 'bulk') {
         wrapperDto = _dtos.BulkResponseDto;

package/cjs/decorators/index.js

@@ -4,9 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 _export_star(require("./api-response.decorator"), exports);
 _export_star(require("./current-user.decorator"), exports);
+_export_star(require("./log-action.decorator"), exports);
 _export_star(require("./public.decorator"), exports);
 _export_star(require("./require-permission.decorator"), exports);
-_export_star(require("./sanitize-html.decorator"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/cjs/decorators/log-action.decorator.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LogAction", {
+    enumerable: true,
+    get: function() {
+        return LogAction;
+    }
+});
+const _common = require("@nestjs/common");
+const _winstonloggerclass = require("../classes/winston.logger.class");
+const _loggermiddleware = require("../middlewares/logger.middleware");
+function createLoggerAdapter(className, moduleName) {
+    if (moduleName) {
+        const winstonLogger = (0, _winstonloggerclass.createModuleLogger)(moduleName);
+        return {
+            log: (level, message, meta)=>{
+                winstonLogger.log(level, message, {
+                    context: className,
+                    ...meta
+                });
+            },
+            error: (message, stack, meta)=>{
+                winstonLogger.error(message, {
+                    context: className,
+                    stack,
+                    ...meta
+                });
+            }
+        };
+    }
+    const nestLogger = new _common.Logger(className);
+    return {
+        log: (level, message, meta)=>{
+            nestLogger[level](message, meta);
+        },
+        error: (message, stack, meta)=>{
+            nestLogger.error(message, stack, meta);
+        }
+    };
+}
+function LogAction(options = {}) {
+    return function(target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const className = target.constructor.name;
+        const methodName = String(propertyKey);
+        descriptor.value = async function(...args) {
+            const startTime = Date.now();
+            // Resolve module: decorator option > instance property > undefined
+            const moduleName = options.module || this.moduleName;
+            const logger = createLoggerAdapter(className, moduleName);
+            const action = options.action || `${this.entityName || className}.${methodName}`;
+            const logLevel = options.logLevel || 'debug';
+            const context = {
+                requestId: (0, _loggermiddleware.getRequestId)(),
+                userId: (0, _loggermiddleware.getUserId)(),
+                tenantId: (0, _loggermiddleware.getTenantId)(),
+                companyId: (0, _loggermiddleware.getCompanyId)(),
+                method: methodName,
+                module: moduleName
+            };
+            const startMessage = `Executing action method "${action}"`;
+            const startContext = options.includeParams ? {
+                ...context,
+                params: sanitizeParams(args)
+            } : context;
+            logger.log(logLevel, startMessage, startContext);
+            try {
+                const result = await originalMethod.apply(this, args);
+                const duration = Date.now() - startTime;
+                const resultType = getResultType(result);
+                const successMessage = `Executed action method "${action}", returned result "${resultType}" in ${duration.toFixed(2)}ms.`;
+                const successContext = options.includeResult && result ? {
+                    ...context,
+                    duration: `${duration}ms`,
+                    resultType,
+                    resultPreview: getResultPreview(result)
+                } : {
+                    ...context,
+                    duration: `${duration}ms`,
+                    resultType
+                };
+                logger.log(logLevel, successMessage, successContext);
+                return result;
+            } catch (error) {
+                const duration = Date.now() - startTime;
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                logger.error(`Failed action method "${action}" after ${duration.toFixed(2)}ms: ${errorMessage}`, error instanceof Error ? error.stack : undefined, {
+                    ...context,
+                    duration: `${duration}ms`,
+                    error: errorMessage
+                });
+                throw error;
+            }
+        };
+        return descriptor;
+    };
+}
+function sanitizeParams(args) {
+    return args.map((arg)=>{
+        if (arg === null || arg === undefined) return arg;
+        if (typeof arg === 'object') {
+            const sanitized = {
+                ...arg
+            };
+            const sensitiveKeys = [
+                'password',
+                'secret',
+                'token',
+                'apiKey',
+                'authorization'
+            ];
+            for (const key of Object.keys(sanitized)){
+                if (sensitiveKeys.some((sk)=>key.toLowerCase().includes(sk))) {
+                    sanitized[key] = '[REDACTED]';
+                }
+            }
+            return sanitized;
+        }
+        return arg;
+    });
+}
+function getResultType(result) {
+    if (result === null) return 'null';
+    if (result === undefined) return 'undefined';
+    if (Array.isArray(result)) return `Array<${result.length} items>`;
+    if (typeof result === 'object') {
+        const name = result.constructor?.name;
+        return name && name !== 'Object' ? name : 'Object';
+    }
+    return typeof result;
+}
+function getResultPreview(result) {
+    if (Array.isArray(result)) {
+        return {
+            count: result.length,
+            sample: result.slice(0, 2)
+        };
+    }
+    if (typeof result === 'object' && result !== null) {
+        const keys = Object.keys(result).slice(0, 5);
+        return {
+            keys,
+            hasMore: Object.keys(result).length > 5
+        };
+    }
+    return result;
+}