@flusys/nestjs-shared 1.0.0-rc → 2.0.0

package/cjs/middlewares/logger.middleware.js

@@ -26,12 +26,6 @@ _export(exports, {
     },
     get requestContext () {
         return requestContext;
-    },
-    get setCompanyId () {
-        return setCompanyId;
-    },
-    get setUserId () {
-        return setUserId;
     }
 });
 const _config = require("@flusys/nestjs-core/config");
@@ -78,14 +72,6 @@ const getRequestId = ()=>requestContext.getStore()?.requestId;
 const getTenantId = ()=>requestContext.getStore()?.tenantId;
 const getUserId = ()=>requestContext.getStore()?.userId;
 const getCompanyId = ()=>requestContext.getStore()?.companyId;
-const setUserId = (userId)=>{
-    const store = requestContext.getStore();
-    if (store) store.userId = userId;
-};
-const setCompanyId = (companyId)=>{
-    const store = requestContext.getStore();
-    if (store) store.companyId = companyId;
-};
 // Helper Functions
 function sanitizeHeaders(headers) {
     const sanitized = {};
@@ -107,84 +93,62 @@ let LoggerMiddleware = class LoggerMiddleware {
         const requestId = req.headers[_constants.REQUEST_ID_HEADER] || (0, _uuid.v4)();
         const tenantId = req.headers[TENANT_ID_HEADER];
         const startTime = Date.now();
-        // Set response header
         res.setHeader(_constants.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));
             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 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),
             userAgent: req.headers['user-agent'],
             contentType: req.headers['content-type'],
             contentLength: req.headers['content-length']
         };
-        // Add debug details if enabled
         if (IS_DEBUG) {
             logData.headers = sanitizeHeaders(req.headers);
             logData.body = truncateBody(req.body);
@@ -196,13 +160,12 @@ let LoggerMiddleware = class LoggerMiddleware {
         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 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`,
@@ -210,33 +173,31 @@ let LoggerMiddleware = class LoggerMiddleware {
             contentType: res.getHeader('content-type'),
             contentLength: res.getHeader('content-length')
         };
-        // 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);
         }
         this.logger.log(level, `Response [${statusCode}]`, logData);
-        // Log slow requests separately
         if (duration > 3000 && statusCode < 400) {
             this.logger.warn('Slow request detected', {
-                context: 'HTTP',
-                requestId,
-                tenantId,
+                ...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", _winstonloggerclass.instance);
     }

package/cjs/modules/datasource/datasource.module.js

@@ -87,24 +87,12 @@ let DataSourceModule = class DataSourceModule {
                     provide: options.useClass,
                     useClass: options.useClass
                 },
-                {
-                    provide: _nestjscore.MODULE_OPTIONS,
-                    useFactory: async (factory)=>factory.createOptions(),
-                    inject: [
-                        options.useClass
-                    ]
-                }
+                this.createFactoryProvider(options.useClass)
             ];
         }
         if (options.useExisting) {
             return [
-                {
-                    provide: _nestjscore.MODULE_OPTIONS,
-                    useFactory: async (factory)=>factory.createOptions(),
-                    inject: [
-                        options.useExisting
-                    ]
-                }
+                this.createFactoryProvider(options.useExisting)
             ];
         }
         return [
@@ -114,6 +102,15 @@ let DataSourceModule = class DataSourceModule {
             }
         ];
     }
+    static createFactoryProvider(factoryClass) {
+        return {
+            provide: _nestjscore.MODULE_OPTIONS,
+            useFactory: async (factory)=>factory.createOptions(),
+            inject: [
+                factoryClass
+            ]
+        };
+    }
 };
 DataSourceModule = _ts_decorate([
     (0, _common.Module)({})

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

@@ -100,10 +100,6 @@ let MultiTenantDataSourceService = class MultiTenantDataSourceService {
         const dataSource = await this.getDataSource();
         return dataSource.getRepository(entity);
     }
-    async getRepositoryForTenant(entity, tenantId) {
-        const dataSource = await this.getDataSourceForTenant(tenantId);
-        return dataSource.getRepository(entity);
-    }
     async withTenant(tenantId, callback) {
         const dataSource = await this.getDataSourceForTenant(tenantId);
         return callback(dataSource);

package/cjs/modules/utils/utils.service.js

@@ -2,25 +2,13 @@
 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 DEFAULT_PHONE_COUNTRY_CODE () {
-        return DEFAULT_PHONE_COUNTRY_CODE;
-    },
-    get DEFAULT_PHONE_REGEX () {
-        return DEFAULT_PHONE_REGEX;
-    },
-    get UtilsService () {
+Object.defineProperty(exports, "UtilsService", {
+    enumerable: true,
+    get: function() {
         return UtilsService;
     }
 });
 const _common = require("@nestjs/common");
-const _classvalidator = require("class-validator");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -40,38 +28,25 @@ 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;
 }
-const DEFAULT_PHONE_REGEX = /^((\+880)|0)?(13|15|16|17|18|19)\d{8}$/;
-const DEFAULT_PHONE_COUNTRY_CODE = '+88';
 let UtilsService = class UtilsService {
-    /**
-   * Configure phone validation regex and country code
-   */ setPhoneValidationConfig(config) {
-        this.phoneConfig = config;
-    }
     // ---------------- CACHE HELPERS ----------------
     /**
    * Generate cache key with optional tenant prefix for multi-tenant isolation
    */ getCacheKey(entityName, params, entityId, tenantId) {
-        const tenantPrefix = tenantId ? `tenant_${tenantId}_` : '';
-        if (entityId) return `${tenantPrefix}entity_${entityName}_id_${entityId}${params ? '_select_' + JSON.stringify(params) : ''}`;
-        return `${tenantPrefix}entity_${entityName}_all_${JSON.stringify(params)}`;
+        const prefix = this.buildTenantPrefix(tenantId);
+        if (entityId) {
+            return `${prefix}entity_${entityName}_id_${entityId}${params ? '_select_' + JSON.stringify(params) : ''}`;
+        }
+        return `${prefix}entity_${entityName}_all_${JSON.stringify(params)}`;
     }
     /**
    * Track cache key for later invalidation with optional tenant prefix
    */ async trackCacheKey(cacheKey, entityName, cacheManager, entityId, tenantId) {
-        const tenantPrefix = tenantId ? `tenant_${tenantId}_` : '';
         try {
-            if (entityId) {
-                const trackingKey = `${tenantPrefix}entity_${entityName}_id_${entityId}_keys`;
-                const idKeys = await cacheManager.get(trackingKey) || [];
-                if (!idKeys.includes(cacheKey)) idKeys.push(cacheKey);
-                await cacheManager.set(trackingKey, idKeys);
-            } else {
-                const trackingKey = `${tenantPrefix}entity_${entityName}_keys`;
-                const allKeys = await cacheManager.get(trackingKey) || [];
-                if (!allKeys.includes(cacheKey)) allKeys.push(cacheKey);
-                await cacheManager.set(trackingKey, allKeys);
-            }
+            const trackingKey = this.buildTrackingKey(entityName, entityId, tenantId);
+            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));
         }
@@ -79,49 +54,15 @@ let UtilsService = class UtilsService {
     /**
    * Clear cache for entity with optional tenant prefix
    */ async clearCache(entityName, cacheManager, entityId, tenantId) {
-        const tenantPrefix = tenantId ? `tenant_${tenantId}_` : '';
         try {
-            if (entityId) {
-                const trackingKey = `${tenantPrefix}entity_${entityName}_id_${entityId}_keys`;
-                const idKeys = await cacheManager.get(trackingKey) || [];
-                await Promise.allSettled(idKeys.map((key)=>cacheManager.del(key)));
-                await cacheManager.del(trackingKey);
-            } else {
-                const trackingKey = `${tenantPrefix}entity_${entityName}_keys`;
-                const keySet = await cacheManager.get(trackingKey) || [];
-                await Promise.allSettled(keySet.map((key)=>cacheManager.del(key)));
-                await cacheManager.del(trackingKey);
-            }
+            const trackingKey = this.buildTrackingKey(entityName, entityId, tenantId);
+            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));
         }
     }
-    // ---------------- VALIDATION HELPERS ----------------
-    /**
-   * Check if value is phone or email and normalize phone number
-   */ checkPhoneOrEmail(value) {
-        if ((0, _classvalidator.isEmail)(value)) {
-            return {
-                value,
-                type: 'email'
-            };
-        }
-        const phoneMatch = value.match(this.phoneConfig.regex);
-        if (phoneMatch) {
-            let phone = phoneMatch[0];
-            if (!phone.startsWith(this.phoneConfig.countryCode)) {
-                phone = this.phoneConfig.countryCode + phone;
-            }
-            return {
-                value: phone,
-                type: 'phone'
-            };
-        }
-        return {
-            value: null,
-            type: null
-        };
-    }
     // ---------------- STRING HELPERS ----------------
     /**
    * Transform string to URL-friendly slug
@@ -129,43 +70,21 @@ let UtilsService = class UtilsService {
         const slug = value?.trim().replace(/[^A-Z0-9]+/gi, '-').toLowerCase();
         return salt ? `${slug}-${this.getRandomInt(1, 100)}` : slug;
     }
-    // ---------------- RANDOM HELPERS ----------------
     /**
    * Generate random integer between min and max (inclusive)
    */ getRandomInt(min, max) {
         return Math.floor(Math.random() * (max - min + 1)) + min;
     }
-    /**
-   * Generate random alphanumeric string
-   */ generateRandomId(length) {
-        const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-        let result = '';
-        for(let i = 0; i < length; i++){
-            result += characters.charAt(Math.floor(Math.random() * characters.length));
-        }
-        return result;
+    // ---------------- PRIVATE HELPERS ----------------
+    buildTenantPrefix(tenantId) {
+        return tenantId ? `tenant_${tenantId}_` : '';
     }
-    /**
-   * Generate 4-digit OTP code
-   */ getRandomOtpCode() {
-        return Math.floor(Math.random() * (9999 - 1000 + 1)) + 1000;
-    }
-    // ---------------- ERROR HELPERS ----------------
-    /**
-   * Extract column name and value from PostgreSQL error detail
-   */ extractColumnNameFromError(detail) {
-        const match = detail.match(/\((.*?)\)=\((.*?)\)/);
-        return {
-            columnName: match ? match[1] : 'unknown',
-            value: match ? match[2] : 'unknown'
-        };
+    buildTrackingKey(entityName, entityId, tenantId) {
+        const prefix = this.buildTenantPrefix(tenantId);
+        return entityId ? `${prefix}entity_${entityName}_id_${entityId}_keys` : `${prefix}entity_${entityName}_keys`;
     }
     constructor(){
         _define_property(this, "logger", new _common.Logger(UtilsService.name));
-        _define_property(this, "phoneConfig", {
-            regex: DEFAULT_PHONE_REGEX,
-            countryCode: DEFAULT_PHONE_COUNTRY_CODE
-        });
     }
 };
 UtilsService = _ts_decorate([

package/cjs/utils/error-handler.util.js

@@ -8,8 +8,6 @@ Object.defineProperty(exports, "ErrorHandler", {
         return ErrorHandler;
     }
 });
-const _common = require("@nestjs/common");
-/** Check if running in production environment */ const IS_PRODUCTION = process.env.NODE_ENV === 'production';
 /** Sensitive keys that should be redacted from logs */ const SENSITIVE_KEYS = [
     'password',
     'secret',
@@ -18,78 +16,23 @@ const _common = require("@nestjs/common");
     'credential',
     'authorization'
 ];
-/** Patterns that indicate sensitive data in error messages */ const SENSITIVE_PATTERNS = [
-    /password/i,
-    /secret/i,
-    /token/i,
-    /key/i,
-    /credential/i,
-    /authorization/i,
-    /bearer/i
-];
 let ErrorHandler = class ErrorHandler {
     /**
    * Safely extract error message from unknown error.
-   * @param error - The error to extract message from
-   * @param sanitizeForClient - If true, redacts potentially sensitive info in production
-   */ static getErrorMessage(error, sanitizeForClient = false) {
-        let message = 'Unknown error occurred';
-        if (error instanceof Error) {
-            message = error.message;
-        } else if (typeof error === 'string') {
-            message = error;
-        }
-        // Sanitize for client responses in production
-        if (sanitizeForClient && IS_PRODUCTION) {
-            if (this.containsSensitiveData(message)) {
-                return 'An unexpected error occurred. Please try again later.';
-            }
-        }
-        return message;
-    }
-    /**
-   * Check if a string contains potentially sensitive data.
-   */ static containsSensitiveData(text) {
-        return SENSITIVE_PATTERNS.some((pattern)=>pattern.test(text));
-    }
-    /**
-   * Safely extract error stack from unknown error.
-   * Returns undefined in production for client responses.
-   * @param error - The error to extract stack from
-   * @param forClient - If true, never returns stack in production
-   */ static getErrorStack(error, forClient = false) {
-        // Never expose stack traces to clients in production
-        if (forClient && IS_PRODUCTION) {
-            return undefined;
-        }
+   */ static getErrorMessage(error) {
         if (error instanceof Error) {
-            return error.stack;
-        }
-        return undefined;
-    }
-    /**
-   * Create a sanitized error response for clients.
-   * In production, sensitive data is redacted and stack traces removed.
-   */ static createClientError(error, statusCode = _common.HttpStatus.INTERNAL_SERVER_ERROR, code) {
-        const sanitizedError = {
-            message: this.getErrorMessage(error, true),
-            statusCode
-        };
-        if (code) {
-            sanitizedError.code = code;
+            return error.message;
         }
-        // Include stack only in development
-        if (!IS_PRODUCTION) {
-            sanitizedError.stack = this.getErrorStack(error);
+        if (typeof error === 'string') {
+            return error;
         }
-        return sanitizedError;
+        return 'Unknown error occurred';
     }
     /**
    * Sanitize context data to redact sensitive fields from logs.
    */ static sanitizeContextForLogging(context) {
         const sanitized = {};
         for (const [key, value] of Object.entries(context)){
-            // Check if key contains sensitive words
             const isSensitive = SENSITIVE_KEYS.some((sk)=>key.toLowerCase().includes(sk.toLowerCase()));
             if (isSensitive) {
                 sanitized[key] = '[REDACTED]';
@@ -105,7 +48,6 @@ let ErrorHandler = class ErrorHandler {
     }
     /**
    * Create error context object for internal logging.
-   * Context data is sanitized to redact sensitive fields.
    */ static createErrorContext(error, context) {
         const errorContext = {
             error: {
@@ -117,29 +59,32 @@ let ErrorHandler = class ErrorHandler {
             errorContext.error.name = error.name;
         }
         if (context && Object.keys(context).length > 0) {
-            // Sanitize context to redact sensitive fields
             errorContext.context = this.sanitizeContextForLogging(context);
         }
         return errorContext;
     }
     /**
    * Log error with consistent format.
-   * Sensitive data in context is automatically redacted.
    */ static logError(logger, error, operation, context) {
         const errorContext = this.createErrorContext(error, {
             operation,
             ...context
         });
         const errorMessage = `Failed to ${operation}: ${errorContext.error.message}`;
-        // Log full details internally (stack traces are fine for internal logs)
         logger.error(errorMessage, errorContext.error.stack, errorContext);
     }
     /**
-   * Re-throw error with proper type checking
+   * Re-throw error with proper type checking.
    */ static rethrowError(error) {
         if (error instanceof Error) {
             throw error;
         }
         throw new Error(`Unexpected error: ${String(error)}`);
     }
+    /**
+   * Log error and re-throw (common pattern).
+   */ static logAndRethrow(logger, error, operation, context) {
+        this.logError(logger, error, operation, context);
+        this.rethrowError(error);
+    }
 };

package/cjs/utils/html-sanitizer.util.js

@@ -16,9 +16,6 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    get containsHtmlContent () {
-        return containsHtmlContent;
-    },
     get escapeHtml () {
         return escapeHtml;
     },
@@ -43,7 +40,7 @@ function escapeHtml(str) {
     if (!str || typeof str !== 'string') {
         return str ?? '';
     }
-    return str.replace(HTML_ESCAPE_REGEX, (char)=>HTML_ESCAPE_MAP[char] || char);
+    return str.replace(HTML_ESCAPE_REGEX, (char)=>HTML_ESCAPE_MAP[char]);
 }
 function escapeHtmlVariables(variables) {
     if (!variables || typeof variables !== 'object') {
@@ -65,10 +62,3 @@ function escapeHtmlVariables(variables) {
     }
     return escaped;
 }
-function containsHtmlContent(str) {
-    if (!str || typeof str !== 'string') {
-        return false;
-    }
-    // Check for common HTML patterns
-    return /<[a-z][\s\S]*>/i.test(str) || /javascript:/i.test(str) || /on\w+=/i.test(str);
-}

package/cjs/utils/index.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 _export_star(require("./error-handler.util"), exports);
 _export_star(require("./html-sanitizer.util"), exports);
 _export_star(require("./query-helpers.util"), exports);
+_export_star(require("./request.util"), exports);
+_export_star(require("./string.util"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {