@flusys/nestjs-shared 3.0.1 → 4.0.0-lts

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

@@ -0,0 +1,157 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { Catch, HttpException, HttpStatus, Logger } from '@nestjs/common';
+import { ERROR_MESSAGES } from '../constants/message-keys';
+import { BaseAppException } from '../exceptions/base-app.exception';
+import { getRequestId, getUserId, getTenantId, getCompanyId } from '../middlewares/logger.middleware';
+export 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 = getRequestId() || request.headers['x-request-id'] || 'no-request-id';
+        const userId = getUserId();
+        const tenantId = getTenantId();
+        const companyId = 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) {
+            return {
+                success: false,
+                message: exception.message,
+                messageKey: exception.messageKey,
+                messageParams: exception.messageParams,
+                errors: exception.errors,
+                _meta: {
+                    requestId,
+                    timestamp,
+                    responseTime
+                }
+            };
+        }
+        if (exception instanceof 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: ERROR_MESSAGES.INTERNAL,
+            _meta: {
+                requestId,
+                timestamp,
+                responseTime
+            }
+        };
+    }
+    extractHttpExceptionDetails(response) {
+        if (typeof response === 'string') {
+            return {
+                message: response,
+                messageKey: 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: ERROR_MESSAGES.VALIDATION,
+                    errors
+                };
+            }
+            return {
+                message: String(obj.message || 'Unknown error'),
+                messageKey: String(obj.messageKey || ERROR_MESSAGES.HTTP),
+                messageParams: obj.messageParams,
+                errors: obj.errors
+            };
+        }
+        return {
+            message: 'Unknown error',
+            messageKey: ERROR_MESSAGES.UNKNOWN
+        };
+    }
+    getStatusCode(exception) {
+        if (exception instanceof HttpException) {
+            return exception.getStatus();
+        }
+        return 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 Logger('ExceptionFilter'));
+    }
+}
+GlobalExceptionFilter = _ts_decorate([
+    Catch()
+], GlobalExceptionFilter);

package/fesm/filters/index.js

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

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

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

package/fesm/guards/permission.guard.js

@@ -25,13 +25,11 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { Inject, Injectable, Logger, Optional, UnauthorizedException } from '@nestjs/common';
+import { Inject, Injectable, Optional, UnauthorizedException } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
 import { HybridCache } from '../classes/hybrid-cache.class';
-import { NestLoggerAdapter } from '../classes/winston-logger-adapter.class';
-import { CACHE_INSTANCE, IS_PUBLIC_KEY, LOGGER_INSTANCE, PERMISSION_GUARD_CONFIG, PERMISSIONS_CACHE_PREFIX, PERMISSIONS_KEY } from '../constants';
+import { AUTH_MESSAGES, CACHE_INSTANCE, IS_PUBLIC_KEY, PERMISSION_GUARD_CONFIG, PERMISSIONS_CACHE_PREFIX, PERMISSIONS_KEY } from '../constants';
 import { InsufficientPermissionsException, NoPermissionsFoundException, PermissionSystemUnavailableException } from '../exceptions/permission.exception';
-import { ILogger } from '../interfaces/logger.interface';
 import { PermissionGuardConfig } from '../interfaces/permission.interface';
 export class PermissionGuard {
     async canActivate(context) {
@@ -47,21 +45,21 @@ export class PermissionGuard {
         if (!permissionConfig) return true;
         const request = context.switchToHttp().getRequest();
         const user = request.user;
-        if (!user) throw new UnauthorizedException('Authentication required');
+        if (!user) throw new UnauthorizedException({
+            message: 'Authentication required',
+            messageKey: AUTH_MESSAGES.TOKEN_REQUIRED
+        });
         if (!this.cache) {
-            this.logger.error(`Cache not available (userId: ${user.id})`, undefined, 'PermissionGuard');
             throw new PermissionSystemUnavailableException();
         }
         const userPermissions = await this.getUserPermissions(user);
         if (!userPermissions || userPermissions.length === 0) {
-            this.logger.warn(`No permissions found (userId: ${user.id})`, 'PermissionGuard');
             throw new 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 InsufficientPermissionsException(result.missingPermissions, result.operator);
         }
         return true;
@@ -168,11 +166,10 @@ export 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 = {
@@ -181,7 +178,6 @@ export class PermissionGuard {
             companyPermissionKeyFormat: `${PERMISSIONS_CACHE_PREFIX}:company:{companyId}:branch:{branchId}:user:{userId}`,
             ...config
         };
-        this.logger = logger || new NestLoggerAdapter(new Logger(PermissionGuard.name));
     }
 }
 PermissionGuard = _ts_decorate([
@@ -191,13 +187,10 @@ PermissionGuard = _ts_decorate([
     _ts_param(1, Inject(CACHE_INSTANCE)),
     _ts_param(2, Optional()),
     _ts_param(2, Inject(PERMISSION_GUARD_CONFIG)),
-    _ts_param(3, Optional()),
-    _ts_param(3, Inject(LOGGER_INSTANCE)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof Reflector === "undefined" ? Object : Reflector,
         typeof HybridCache === "undefined" ? Object : HybridCache,
-        typeof PermissionGuardConfig === "undefined" ? Object : PermissionGuardConfig,
-        typeof ILogger === "undefined" ? Object : ILogger
+        typeof PermissionGuardConfig === "undefined" ? Object : PermissionGuardConfig
     ])
 ], PermissionGuard);

package/fesm/index.js

@@ -5,6 +5,7 @@ export * from './dtos';
 export * from './entities';
 export * from './enums';
 export * from './exceptions';
+export * from './filters';
 export * from './guards';
 export * from './interceptors';
 export * from './interfaces';

package/fesm/interceptors/idempotency.interceptor.js

@@ -29,7 +29,7 @@ import { ConflictException, Inject, Injectable, Optional } from '@nestjs/common'
 import { of } from 'rxjs';
 import { tap } from 'rxjs/operators';
 import { HybridCache } from '../classes/hybrid-cache.class';
-import { CACHE_INSTANCE, IDEMPOTENCY_CACHE_PREFIX, IDEMPOTENCY_KEY_HEADER } from '../constants';
+import { CACHE_INSTANCE, IDEMPOTENCY_CACHE_PREFIX, IDEMPOTENCY_KEY_HEADER, SYSTEM_MESSAGES } from '../constants';
 export class IdempotencyInterceptor {
     async intercept(context, next) {
         // Skip if no cache available
@@ -51,7 +51,7 @@ export class IdempotencyInterceptor {
                 throw new ConflictException({
                     success: false,
                     message: 'Request is already being processed',
-                    code: 'DUPLICATE_REQUEST_IN_PROGRESS'
+                    messageKey: SYSTEM_MESSAGES.DUPLICATE_REQUEST
                 });
             }
             // Return cached response

package/fesm/interceptors/index.js

@@ -1,6 +1,5 @@
 export * from './delete-empty-id-from-body.interceptor';
 export * from './idempotency.interceptor';
-export * from './query-performance.interceptor';
 export * from './response-meta.interceptor';
 export * from './set-user-field-on-body.interceptor';
 export * from './slug.interceptor';

package/fesm/interfaces/logger.interface.js

@@ -1,4 +1 @@
-/**
- * Logger interface for dependency injection
- * Compatible with Winston, NestJS Logger, and console
- */ export { };
+export { };

package/fesm/middlewares/logger.middleware.js

@@ -24,18 +24,15 @@ import { v4 as uuidv4 } from 'uuid';
 import { instance as winstonLogger } from '../classes/winston.logger.class';
 import { REQUEST_ID_HEADER } from '../constants';
 // Configuration
-const IS_DEBUG = envConfig.getLogConfig().level === 'debug';
+const logConfig = envConfig.getLogConfig();
+const IS_DEBUG = logConfig.level === 'debug';
+const DISABLE_HTTP_LOGGING = logConfig.disableHttpLogging;
 const TENANT_ID_HEADER = 'x-tenant-id';
 const EXCLUDED_PATHS = [
     '/health',
     '/metrics',
     '/favicon.ico'
 ];
-const EXCLUDED_HEADERS = [
-    'authorization',
-    'cookie',
-    'x-api-key'
-];
 const MAX_BODY_LOG_SIZE = 1000;
 export const requestContext = new AsyncLocalStorage();
 // Context accessors
@@ -44,17 +41,71 @@ export const getTenantId = ()=>requestContext.getStore()?.tenantId;
 export const getUserId = ()=>requestContext.getStore()?.userId;
 export const getCompanyId = ()=>requestContext.getStore()?.companyId;
 // Helper Functions
-function sanitizeHeaders(headers) {
-    const sanitized = {};
-    for (const [key, value] of Object.entries(headers)){
-        sanitized[key] = EXCLUDED_HEADERS.includes(key.toLowerCase()) ? '[REDACTED]' : value;
+function summarizeRequestBody(body) {
+    if (!body) return undefined;
+    const parsed = typeof body === 'string' ? tryParseJson(body) : body;
+    if (!parsed || typeof parsed !== 'object') {
+        const str = String(body);
+        return str.length > MAX_BODY_LOG_SIZE ? str.substring(0, MAX_BODY_LOG_SIZE) + '...' : str;
+    }
+    // For API request bodies, provide a concise summary
+    const summary = {};
+    // Pagination info
+    if (parsed.pagination) {
+        summary.page = parsed.pagination.currentPage;
+        summary.pageSize = parsed.pagination.pageSize;
+    }
+    // Filter keys only (not values - may contain sensitive data)
+    if (parsed.filter && typeof parsed.filter === 'object') {
+        const filterKeys = Object.keys(parsed.filter);
+        if (filterKeys.length > 0) summary.filterKeys = filterKeys;
+    }
+    // Select fields count
+    if (Array.isArray(parsed.select) && parsed.select.length > 0) {
+        summary.selectCount = parsed.select.length;
+    }
+    // Sort keys
+    if (parsed.sort && typeof parsed.sort === 'object') {
+        const sortKeys = Object.keys(parsed.sort);
+        if (sortKeys.length > 0) summary.sortKeys = sortKeys;
     }
-    return sanitized;
+    // ID for single item operations
+    if (parsed.id) summary.id = parsed.id;
+    // IDs for bulk operations
+    if (Array.isArray(parsed.ids)) summary.idsCount = parsed.ids.length;
+    return Object.keys(summary).length > 0 ? JSON.stringify(summary) : '{}';
 }
-function truncateBody(body) {
+function summarizeResponseBody(body) {
     if (!body) return undefined;
-    const str = typeof body === 'string' ? body : JSON.stringify(body);
-    return str.length > MAX_BODY_LOG_SIZE ? str.substring(0, MAX_BODY_LOG_SIZE) + '...' : body;
+    const parsed = typeof body === 'string' ? tryParseJson(body) : body;
+    if (!parsed || typeof parsed !== 'object') {
+        const str = String(body);
+        return str.length > MAX_BODY_LOG_SIZE ? str.substring(0, MAX_BODY_LOG_SIZE) + '...' : str;
+    }
+    const summary = {};
+    if ('success' in parsed) summary.success = parsed.success;
+    if ('message' in parsed) summary.message = parsed.message;
+    if ('code' in parsed) summary.code = parsed.code;
+    if (Array.isArray(parsed.data)) {
+        summary.dataCount = parsed.data.length;
+    } else if (parsed.data && typeof parsed.data === 'object') {
+        summary.hasData = true;
+    }
+    if (parsed.meta) {
+        summary.total = parsed.meta.total;
+        summary.page = parsed.meta.page;
+    }
+    if (parsed.errors) {
+        summary.errorsCount = Array.isArray(parsed.errors) ? parsed.errors.length : 1;
+    }
+    return JSON.stringify(summary);
+}
+function tryParseJson(str) {
+    try {
+        return JSON.parse(str);
+    } catch  {
+        return null;
+    }
 }
 function getClientIp(req) {
     return req.headers['x-forwarded-for']?.split(',')[0] || req.socket?.remoteAddress || 'unknown';
@@ -71,7 +122,7 @@ export class LoggerMiddleware {
             startTime
         };
         requestContext.run(context, ()=>{
-            const shouldSkipLogging = EXCLUDED_PATHS.some((path)=>req.originalUrl.startsWith(path));
+            const shouldSkipLogging = DISABLE_HTTP_LOGGING || EXCLUDED_PATHS.some((path)=>req.originalUrl.startsWith(path));
             if (!shouldSkipLogging) {
                 this.logRequest(req, requestId, tenantId);
                 this.setupResponseLogging(req, res, startTime, requestId, tenantId);
@@ -112,20 +163,22 @@ export class LoggerMiddleware {
         });
     }
     logRequest(req, requestId, tenantId) {
+        const ip = getClientIp(req);
+        const contentType = req.headers['content-type'] || 'none';
+        // Build descriptive message like: Started processing request "POST" "/api/users" from "192.168.1.1"
+        const message = `Started processing request "${req.method}" "${req.originalUrl}" from "${ip}"`;
         const logData = {
             ...this.buildBaseLogData(req, requestId, tenantId),
             query: Object.keys(req.query).length > 0 ? req.query : undefined,
-            ip: getClientIp(req),
+            ip,
             userAgent: req.headers['user-agent'],
-            contentType: req.headers['content-type'],
+            contentType,
             contentLength: req.headers['content-length']
         };
         if (IS_DEBUG) {
-            logData.headers = sanitizeHeaders(req.headers);
-            logData.body = truncateBody(req.body);
-            logData.params = Object.keys(req.params).length > 0 ? req.params : undefined;
+            logData.body = summarizeRequestBody(req.body);
         }
-        this.logger.info('Incoming request', logData);
+        this.logger.info(message, logData);
     }
     logResponse(req, res, startTime, body, requestId, tenantId) {
         const duration = Date.now() - startTime;
@@ -133,6 +186,10 @@ export class LoggerMiddleware {
         const level = statusCode >= 500 ? 'error' : statusCode >= 400 ? 'warn' : 'info';
         const userId = getUserId();
         const companyId = getCompanyId();
+        const contentType = res.getHeader('content-type') || 'none';
+        const contentLength = res.getHeader('content-length') || 'null';
+        // Build descriptive message like: Request finished "HTTP/1.1" "POST" "/api/users" - 200 "application/json" 534.29ms
+        const message = `Request finished "HTTP/1.1" "${req.method}" "${req.originalUrl}" - ${statusCode} ${contentLength} "${contentType}" ${duration.toFixed(2)}ms`;
         const logData = {
             ...this.buildBaseLogData(req, requestId, tenantId),
             userId,
@@ -141,15 +198,15 @@ export class LoggerMiddleware {
             statusMessage: res.statusMessage,
             duration: `${duration}ms`,
             durationMs: duration,
-            contentType: res.getHeader('content-type'),
-            contentLength: res.getHeader('content-length')
+            contentType,
+            contentLength
         };
         if (statusCode >= 400 || IS_DEBUG) {
-            logData.responseBody = truncateBody(body);
+            logData.responseBody = summarizeResponseBody(body);
         }
-        this.logger.log(level, `Response [${statusCode}]`, logData);
+        this.logger.log(level, message, logData);
         if (duration > 3000 && statusCode < 400) {
-            this.logger.warn('Slow request detected', {
+            this.logger.warn(`Slow request detected: "${req.method}" "${req.originalUrl}" took ${duration}ms (threshold: 3000ms)`, {
                 ...this.buildBaseLogData(req, requestId, tenantId),
                 userId,
                 companyId,

package/fesm/modules/datasource/multi-tenant-datasource.service.js

@@ -26,7 +26,8 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { DEFAULT_TENANT_HEADER, IDataSourceServiceOptions, MODULE_OPTIONS } from '@flusys/nestjs-core';
-import { BadRequestException, Inject, Injectable, Logger, Optional, Scope } from '@nestjs/common';
+import { BadRequestException, Inject, Injectable, InternalServerErrorException, Optional, Scope } from '@nestjs/common';
+import { SYSTEM_MESSAGES } from '../../constants';
 import { REQUEST } from '@nestjs/core';
 import { Request } from 'express';
 import { DataSource } from 'typeorm';
@@ -58,7 +59,10 @@ export class MultiTenantDataSourceService {
         const tenantId = this.request.headers[this.tenantHeader];
         if (!tenantId) return null;
         if (!/^[a-zA-Z0-9_-]+$/.test(tenantId)) {
-            throw new BadRequestException('Invalid tenant ID format');
+            throw new BadRequestException({
+                message: 'Invalid tenant ID format',
+                messageKey: SYSTEM_MESSAGES.INVALID_TENANT_ID
+            });
         }
         return tenantId;
     }
@@ -80,7 +84,15 @@ export class MultiTenantDataSourceService {
     }
     async getDataSourceForTenant(tenantId) {
         const tenant = this.getTenant(tenantId);
-        if (!tenant) throw new Error(`Tenant '${tenantId}' not found`);
+        if (!tenant) {
+            throw new BadRequestException({
+                message: `Tenant '${tenantId}' not found`,
+                messageKey: SYSTEM_MESSAGES.TENANT_NOT_FOUND,
+                messageParams: {
+                    tenantId
+                }
+            });
+        }
         return this.getOrCreateTenantConnection(tenant);
     }
     setDataSource(dataSource) {
@@ -100,8 +112,8 @@ export class MultiTenantDataSourceService {
             try {
                 const dataSource = await this.getOrCreateTenantConnection(tenant);
                 results.set(tenant.id, await callback(tenant, dataSource));
-            } catch (error) {
-                this.logger.error(`Error processing tenant ${tenant.id}: ${error}`);
+            } catch  {
+            // Silent failure for individual tenant
             }
         }
         return results;
@@ -118,7 +130,6 @@ export class MultiTenantDataSourceService {
         if (connection?.isInitialized) {
             await connection.destroy();
             MultiTenantDataSourceService.tenantConnections.delete(tenantId);
-            this.logger.log(`Closed connection for tenant: ${tenantId}`);
         }
     }
     async onModuleDestroy() {
@@ -148,7 +159,10 @@ export class MultiTenantDataSourceService {
         }
         const config = this.getDefaultDatabaseConfig();
         if (!config) {
-            throw new Error('No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.');
+            throw new InternalServerErrorException({
+                message: 'No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.',
+                messageKey: SYSTEM_MESSAGES.DATABASE_CONFIG_NOT_AVAILABLE
+            });
         }
         // Create connection with lock to prevent race conditions
         const connectionPromise = this.createDataSourceFromConfig(config);
@@ -166,7 +180,13 @@ export class MultiTenantDataSourceService {
    */ async getTenantDataSource() {
         const tenant = this.getCurrentTenant();
         if (!tenant) {
-            throw new Error(`Tenant not found. Ensure '${this.tenantHeader}' header is set.`);
+            throw new BadRequestException({
+                message: `Tenant not found. Ensure '${this.tenantHeader}' header is set.`,
+                messageKey: SYSTEM_MESSAGES.TENANT_HEADER_REQUIRED,
+                messageParams: {
+                    header: this.tenantHeader
+                }
+            });
         }
         return this.getOrCreateTenantConnection(tenant);
     }
@@ -181,7 +201,6 @@ export class MultiTenantDataSourceService {
         try {
             const dataSource = await connectionPromise;
             MultiTenantDataSourceService.tenantConnections.set(tenant.id, dataSource);
-            this.logger.log(`Created connection for tenant: ${tenant.id}`);
             return dataSource;
         } finally{
             MultiTenantDataSourceService.connectionLocks.delete(tenant.id);
@@ -192,7 +211,12 @@ export class MultiTenantDataSourceService {
     }
     buildTenantDatabaseConfig(tenant) {
         const defaultConfig = this.getDefaultDatabaseConfig();
-        if (!defaultConfig) throw new Error('No default database config for multi-tenant mode.');
+        if (!defaultConfig) {
+            throw new InternalServerErrorException({
+                message: 'No default database config for multi-tenant mode.',
+                messageKey: SYSTEM_MESSAGES.DATABASE_CONFIG_NOT_AVAILABLE
+            });
+        }
         return {
             type: defaultConfig.type,
             host: tenant.host ?? defaultConfig.host,
@@ -220,11 +244,9 @@ export class MultiTenantDataSourceService {
     constructor(options, request){
         _define_property(this, "options", void 0);
         _define_property(this, "request", void 0);
-        _define_property(this, "logger", void 0);
         _define_property(this, "tenantHeader", void 0);
         this.options = options;
         this.request = request;
-        this.logger = new Logger(this.constructor.name);
         this.tenantHeader = DEFAULT_TENANT_HEADER;
         this.initializeFromOptions();
     }

package/fesm/modules/utils/utils.service.js

@@ -1,23 +1,10 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
 function _ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-import { Injectable, Logger } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
 export class UtilsService {
     // ---------------- CACHE HELPERS ----------------
     /**
@@ -37,8 +24,8 @@ export class UtilsService {
             const keys = await cacheManager.get(trackingKey) || [];
             if (!keys.includes(cacheKey)) keys.push(cacheKey);
             await cacheManager.set(trackingKey, keys);
-        } catch (error) {
-            this.logger.error(`Cache tracking failed for ${entityName}`, error instanceof Error ? error.stack : String(error));
+        } catch  {
+        // Silent failure - cache tracking is non-critical
         }
     }
     /**
@@ -49,8 +36,8 @@ export class UtilsService {
             const keys = await cacheManager.get(trackingKey) || [];
             await Promise.allSettled(keys.map((key)=>cacheManager.del(key)));
             await cacheManager.del(trackingKey);
-        } catch (error) {
-            this.logger.error(`Cache invalidation failed for ${entityName}`, error instanceof Error ? error.stack : String(error));
+        } catch  {
+        // Silent failure - cache invalidation is non-critical
         }
     }
     // ---------------- STRING HELPERS ----------------
@@ -73,9 +60,6 @@ export class UtilsService {
         const prefix = this.buildTenantPrefix(tenantId);
         return entityId ? `${prefix}entity_${entityName}_id_${entityId}_keys` : `${prefix}entity_${entityName}_keys`;
     }
-    constructor(){
-        _define_property(this, "logger", new Logger(UtilsService.name));
-    }
 }
 UtilsService = _ts_decorate([
     Injectable()

package/fesm/utils/index.js

@@ -1,4 +1,3 @@
-export * from './error-handler.util';
 export * from './html-sanitizer.util';
 export * from './query-helpers.util';
 export * from './request.util';