@flusys/nestjs-shared 3.0.1 → 4.0.0-lts

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

@@ -42,6 +42,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)) {

package/cjs/constants/message-keys.js

@@ -0,0 +1,80 @@
+// ==================== SHARED/SYSTEM MESSAGE KEYS ====================
+// Package-specific messages are now in their respective packages:
+// - nestjs-auth/src/config/message-keys.ts
+// - nestjs-iam/src/config/message-keys.ts
+// - nestjs-storage/src/config/message-keys.ts
+// - nestjs-email/src/config/message-keys.ts
+// - nestjs-form-builder/src/config/message-keys.ts
+// - nestjs-event-manager/src/config/message-keys.ts
+// - nestjs-notification/src/config/message-keys.ts
+// - nestjs-localization/src/config/message-keys.ts
+// ==================== 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 MESSAGE_KEYS () {
+        return MESSAGE_KEYS;
+    },
+    get SYSTEM_MESSAGES () {
+        return SYSTEM_MESSAGES;
+    }
+});
+const AUTH_MESSAGES = {
+    TOKEN_REQUIRED: 'auth.token.required',
+    TOKEN_INVALID: 'auth.token.invalid',
+    TOKEN_EXPIRED: 'auth.token.expired',
+    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',
+    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'
+};
+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',
+    NOT_FOUND: 'system.not.found',
+    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'
+};
+const MESSAGE_KEYS = {
+    AUTH: AUTH_MESSAGES,
+    ERROR: ERROR_MESSAGES,
+    SYSTEM: SYSTEM_MESSAGES
+};

package/cjs/constants/permissions.js

@@ -46,6 +46,9 @@ _export(exports, {
     get FORM_RESULT_PERMISSIONS () {
         return FORM_RESULT_PERMISSIONS;
     },
+    get LANGUAGE_PERMISSIONS () {
+        return LANGUAGE_PERMISSIONS;
+    },
     get NOTIFICATION_PERMISSIONS () {
         return NOTIFICATION_PERMISSIONS;
     },
@@ -61,6 +64,12 @@ _export(exports, {
     get STORAGE_CONFIG_PERMISSIONS () {
         return STORAGE_CONFIG_PERMISSIONS;
     },
+    get TRANSLATION_KEY_PERMISSIONS () {
+        return TRANSLATION_KEY_PERMISSIONS;
+    },
+    get TRANSLATION_PERMISSIONS () {
+        return TRANSLATION_PERMISSIONS;
+    },
     get USER_ACTION_PERMISSIONS () {
         return USER_ACTION_PERMISSIONS;
     },
@@ -177,6 +186,24 @@ const NOTIFICATION_PERMISSIONS = {
     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 PERMISSIONS = {
     // Auth
     USER: USER_PERMISSIONS,
@@ -203,5 +230,9 @@ const PERMISSIONS = {
     EVENT: EVENT_PERMISSIONS,
     EVENT_PARTICIPANT: EVENT_PARTICIPANT_PERMISSIONS,
     // Notification
-    NOTIFICATION: NOTIFICATION_PERMISSIONS
+    NOTIFICATION: NOTIFICATION_PERMISSIONS,
+    // Localization
+    LANGUAGE: LANGUAGE_PERMISSIONS,
+    TRANSLATION_KEY: TRANSLATION_KEY_PERMISSIONS,
+    TRANSLATION: TRANSLATION_PERMISSIONS
 };

package/cjs/decorators/index.js

@@ -4,6 +4,7 @@ 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);

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;
+}

package/cjs/dtos/response-payload.dto.js

@@ -83,6 +83,8 @@ let SingleResponseDto = class SingleResponseDto {
     constructor(){
         _define_property(this, "success", void 0);
         _define_property(this, "message", void 0);
+        _define_property(this, "messageKey", void 0);
+        _define_property(this, "messageVariables", void 0);
         _define_property(this, "data", void 0);
         _define_property(this, "_meta", void 0);
     }
@@ -99,6 +101,22 @@ _ts_decorate([
     }),
     _ts_metadata("design:type", String)
 ], SingleResponseDto.prototype, "message", void 0);
+_ts_decorate([
+    (0, _swagger.ApiPropertyOptional)({
+        example: 'user.create.success',
+        description: 'Translation key for localization'
+    }),
+    _ts_metadata("design:type", String)
+], SingleResponseDto.prototype, "messageKey", void 0);
+_ts_decorate([
+    (0, _swagger.ApiPropertyOptional)({
+        example: {
+            name: 'John'
+        },
+        description: 'Variables for message interpolation'
+    }),
+    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], SingleResponseDto.prototype, "messageVariables", void 0);
 _ts_decorate([
     (0, _swagger.ApiPropertyOptional)(),
     _ts_metadata("design:type", typeof T === "undefined" ? Object : T)
@@ -162,6 +180,8 @@ let ListResponseDto = class ListResponseDto {
     constructor(){
         _define_property(this, "success", void 0);
         _define_property(this, "message", void 0);
+        _define_property(this, "messageKey", void 0);
+        _define_property(this, "messageVariables", void 0);
         _define_property(this, "data", void 0);
         _define_property(this, "meta", void 0);
         _define_property(this, "_meta", void 0);
@@ -179,6 +199,22 @@ _ts_decorate([
     }),
     _ts_metadata("design:type", String)
 ], ListResponseDto.prototype, "message", void 0);
+_ts_decorate([
+    (0, _swagger.ApiPropertyOptional)({
+        example: 'user.list.success',
+        description: 'Translation key for localization'
+    }),
+    _ts_metadata("design:type", String)
+], ListResponseDto.prototype, "messageKey", void 0);
+_ts_decorate([
+    (0, _swagger.ApiPropertyOptional)({
+        example: {
+            count: 10
+        },
+        description: 'Variables for message interpolation'
+    }),
+    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], ListResponseDto.prototype, "messageVariables", void 0);
 _ts_decorate([
     (0, _swagger.ApiPropertyOptional)({
         isArray: true
@@ -229,6 +265,8 @@ let BulkResponseDto = class BulkResponseDto {
     constructor(){
         _define_property(this, "success", void 0);
         _define_property(this, "message", void 0);
+        _define_property(this, "messageKey", void 0);
+        _define_property(this, "messageVariables", void 0);
         _define_property(this, "data", void 0);
         _define_property(this, "meta", void 0);
         _define_property(this, "_meta", void 0);
@@ -246,6 +284,22 @@ _ts_decorate([
     }),
     _ts_metadata("design:type", String)
 ], BulkResponseDto.prototype, "message", void 0);
+_ts_decorate([
+    (0, _swagger.ApiPropertyOptional)({
+        example: 'user.bulk.success',
+        description: 'Translation key for localization'
+    }),
+    _ts_metadata("design:type", String)
+], BulkResponseDto.prototype, "messageKey", void 0);
+_ts_decorate([
+    (0, _swagger.ApiPropertyOptional)({
+        example: {
+            count: 5
+        },
+        description: 'Variables for message interpolation'
+    }),
+    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], BulkResponseDto.prototype, "messageVariables", void 0);
 _ts_decorate([
     (0, _swagger.ApiPropertyOptional)({
         isArray: true
@@ -271,6 +325,8 @@ let MessageResponseDto = class MessageResponseDto {
     constructor(){
         _define_property(this, "success", void 0);
         _define_property(this, "message", void 0);
+        _define_property(this, "messageKey", void 0);
+        _define_property(this, "messageVariables", void 0);
         _define_property(this, "_meta", void 0);
     }
 };
@@ -286,6 +342,22 @@ _ts_decorate([
     }),
     _ts_metadata("design:type", String)
 ], MessageResponseDto.prototype, "message", void 0);
+_ts_decorate([
+    (0, _swagger.ApiPropertyOptional)({
+        example: 'user.delete.success',
+        description: 'Translation key for localization'
+    }),
+    _ts_metadata("design:type", String)
+], MessageResponseDto.prototype, "messageKey", void 0);
+_ts_decorate([
+    (0, _swagger.ApiPropertyOptional)({
+        example: {
+            count: 3
+        },
+        description: 'Variables for message interpolation'
+    }),
+    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], MessageResponseDto.prototype, "messageVariables", void 0);
 _ts_decorate([
     (0, _swagger.ApiPropertyOptional)({
         type: RequestMetaDto