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

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
@@ -43,26 +40,72 @@ export const getRequestId = ()=>requestContext.getStore()?.requestId;
 export const getTenantId = ()=>requestContext.getStore()?.tenantId;
 export const getUserId = ()=>requestContext.getStore()?.userId;
 export const getCompanyId = ()=>requestContext.getStore()?.companyId;
-export const setUserId = (userId)=>{
-    const store = requestContext.getStore();
-    if (store) store.userId = userId;
-};
-export const setCompanyId = (companyId)=>{
-    const store = requestContext.getStore();
-    if (store) store.companyId = 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';
@@ -72,136 +115,117 @@ export class LoggerMiddleware {
         const requestId = req.headers[REQUEST_ID_HEADER] || uuidv4();
         const tenantId = req.headers[TENANT_ID_HEADER];
         const startTime = Date.now();
-        // Set response header
         res.setHeader(REQUEST_ID_HEADER, requestId);
-        // Create context
         const context = {
             requestId,
             tenantId,
             startTime
         };
-        // Run in AsyncLocalStorage context
         requestContext.run(context, ()=>{
-            // Check if we should skip logging
-            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);
-                // Track if response was already logged
-                let responseLogged = false;
-                // Capture response using multiple hooks to ensure we catch it
-                const originalSend = res.send;
-                const originalJson = res.json;
-                const originalEnd = res.end;
-                // Store reference to this for use in callbacks
-                const self = this;
-                // Override res.send
-                res.send = function(body) {
-                    if (!responseLogged) {
-                        responseLogged = true;
-                        self.logResponse(req, res, startTime, body, requestId, tenantId);
-                    }
-                    return originalSend.call(this, body);
-                };
-                // Override res.json
-                res.json = function(body) {
-                    if (!responseLogged) {
-                        responseLogged = true;
-                        self.logResponse(req, res, startTime, body, requestId, tenantId);
-                    }
-                    return originalJson.call(this, body);
-                };
-                // Override res.end as fallback
-                res.end = function(...args) {
-                    if (!responseLogged) {
-                        responseLogged = true;
-                        self.logResponse(req, res, startTime, args[0], requestId, tenantId);
-                    }
-                    return originalEnd.apply(this, args);
-                };
-                // Handle errors
-                res.on('error', (error)=>{
-                    this.logger.error('Response error', {
-                        context: 'HTTP',
-                        requestId,
-                        tenantId,
-                        method: req.method,
-                        url: req.originalUrl,
-                        path: req.path,
-                        error: error.message,
-                        stack: error.stack
-                    });
-                });
+                this.setupResponseLogging(req, res, startTime, requestId, tenantId);
             }
             next();
         });
     }
+    setupResponseLogging(req, res, startTime, requestId, tenantId) {
+        let responseLogged = false;
+        const originalSend = res.send;
+        const originalJson = res.json;
+        const originalEnd = res.end;
+        const self = this;
+        const logOnce = (body)=>{
+            if (!responseLogged) {
+                responseLogged = true;
+                self.logResponse(req, res, startTime, body, requestId, tenantId);
+            }
+        };
+        res.send = function(body) {
+            logOnce(body);
+            return originalSend.call(this, body);
+        };
+        res.json = function(body) {
+            logOnce(body);
+            return originalJson.call(this, body);
+        };
+        res.end = function(...args) {
+            logOnce(args[0]);
+            return originalEnd.apply(this, args);
+        };
+        res.on('error', (error)=>{
+            this.logger.error('Response error', {
+                ...this.buildBaseLogData(req, requestId, tenantId),
+                error: error.message,
+                stack: error.stack
+            });
+        });
+    }
     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 = {
-            context: 'HTTP',
-            requestId,
-            tenantId,
-            method: req.method,
-            url: req.originalUrl,
-            path: req.path,
+            ...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']
         };
-        // Add debug details if enabled
         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;
         const statusCode = res.statusCode;
         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 = {
-            context: 'HTTP',
-            requestId,
-            tenantId,
-            method: req.method,
-            url: req.originalUrl,
-            path: req.path,
+            ...this.buildBaseLogData(req, requestId, tenantId),
+            userId,
+            companyId,
             statusCode,
             statusMessage: res.statusMessage,
             duration: `${duration}ms`,
             durationMs: duration,
-            contentType: res.getHeader('content-type'),
-            contentLength: res.getHeader('content-length')
+            contentType,
+            contentLength
         };
-        // Add user context if available
-        const userId = getUserId();
-        const companyId = getCompanyId();
-        if (userId) logData.userId = userId;
-        if (companyId) logData.companyId = companyId;
-        // Add response body for errors or debug mode
         if (statusCode >= 400 || IS_DEBUG) {
-            logData.responseBody = truncateBody(body);
+            logData.responseBody = summarizeResponseBody(body);
         }
-        this.logger.log(level, `Response [${statusCode}]`, logData);
-        // Log slow requests separately
+        this.logger.log(level, message, logData);
         if (duration > 3000 && statusCode < 400) {
-            this.logger.warn('Slow request detected', {
-                context: 'HTTP',
-                requestId,
-                tenantId,
+            this.logger.warn(`Slow request detected: "${req.method}" "${req.originalUrl}" took ${duration}ms (threshold: 3000ms)`, {
+                ...this.buildBaseLogData(req, requestId, tenantId),
                 userId,
                 companyId,
-                method: req.method,
-                url: req.originalUrl,
-                path: req.path,
                 duration: `${duration}ms`,
                 durationMs: duration,
                 threshold: '3000ms'
             });
         }
     }
+    buildBaseLogData(req, requestId, tenantId) {
+        return {
+            context: 'HTTP',
+            requestId,
+            tenantId,
+            method: req.method,
+            url: req.originalUrl,
+            path: req.path
+        };
+    }
     constructor(){
         _define_property(this, "logger", winstonLogger);
     }

package/fesm/modules/cache/cache.module.js

@@ -4,8 +4,8 @@ function _ts_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 { HybridCache } from '@flusys/nestjs-shared/classes';
-import { CACHE_INSTANCE } from '@flusys/nestjs-shared/constants';
+import { HybridCache } from '../../classes/hybrid-cache.class';
+import { CACHE_INSTANCE } from '../../constants';
 import { Module } from '@nestjs/common';
 export class CacheModule {
     static forRoot(isGlobal = true, memoryTtl = 60_000, memorySize = 5000) {

package/fesm/modules/datasource/index.js

@@ -1,2 +1 @@
-export * from './datasource.module';
 export * from './multi-tenant-datasource.service';