@flusys/nestjs-shared 1.0.0-rc → 2.0.0

package/fesm/guards/permission.guard.js

@@ -66,17 +66,7 @@ export class PermissionGuard {
                 throw new InsufficientPermissionsException(result.missingPermissions, result.operator);
             }
         } else {
-            let hasRequired;
-            if (operator === 'or') {
-                hasRequired = requiredPermissions.some((p)=>this.hasPermission(userPermissions, p));
-                if (!hasRequired) throw new InsufficientPermissionsException(requiredPermissions, 'or');
-            } else {
-                hasRequired = requiredPermissions.every((p)=>this.hasPermission(userPermissions, p));
-                if (!hasRequired) {
-                    const missing = requiredPermissions.filter((p)=>!this.hasPermission(userPermissions, p));
-                    throw new InsufficientPermissionsException(missing, 'and');
-                }
-            }
+            this.validateSimplePermissions(requiredPermissions, userPermissions, operator);
         }
         return true;
     }
@@ -90,6 +80,18 @@ export class PermissionGuard {
             operator: config.operator || 'and'
         };
     }
+    validateSimplePermissions(requiredPermissions, userPermissions, operator) {
+        if (operator === 'or') {
+            const hasAny = requiredPermissions.some((p)=>this.hasPermission(userPermissions, p));
+            if (!hasAny) throw new InsufficientPermissionsException(requiredPermissions, 'or');
+        } else {
+            const hasAll = requiredPermissions.every((p)=>this.hasPermission(userPermissions, p));
+            if (!hasAll) {
+                const missing = requiredPermissions.filter((p)=>!this.hasPermission(userPermissions, p));
+                throw new InsufficientPermissionsException(missing, 'and');
+            }
+        }
+    }
     isNestedCondition(config) {
         if (Array.isArray(config)) return false;
         return 'children' in config && Array.isArray(config.children) && config.children.length > 0;
@@ -146,15 +148,14 @@ export class PermissionGuard {
     }
     async getUserPermissions(user) {
         if (!this.cache) throw new PermissionSystemUnavailableException();
-        let cacheKey;
+        const cacheKey = this.buildPermissionCacheKey(user);
+        return await this.cache.get(cacheKey) || [];
+    }
+    buildPermissionCacheKey(user) {
         if (this.config.enableCompanyFeature && user.companyId) {
-            const format = this.config.companyPermissionKeyFormat || `${PERMISSIONS_CACHE_PREFIX}:company:{companyId}:branch:{branchId}:user:{userId}`;
-            cacheKey = format.replace('{userId}', user.id).replace('{companyId}', user.companyId).replace('{branchId}', user.branchId || 'null');
-        } else {
-            const format = this.config.userPermissionKeyFormat || `${PERMISSIONS_CACHE_PREFIX}:user:{userId}`;
-            cacheKey = format.replace('{userId}', user.id);
+            return (this.config.companyPermissionKeyFormat || `${PERMISSIONS_CACHE_PREFIX}:company:{companyId}:branch:{branchId}:user:{userId}`).replace('{userId}', user.id).replace('{companyId}', user.companyId).replace('{branchId}', user.branchId || 'null');
         }
-        return await this.cache.get(cacheKey) || [];
+        return (this.config.userPermissionKeyFormat || `${PERMISSIONS_CACHE_PREFIX}:user:{userId}`).replace('{userId}', user.id);
     }
     hasPermission(userPermissions, requiredPermission) {
         if (userPermissions.includes(requiredPermission)) return true;

package/fesm/interceptors/index.js

@@ -3,7 +3,4 @@ export * from './idempotency.interceptor';
 export * from './query-performance.interceptor';
 export * from './response-meta.interceptor';
 export * from './set-user-field-on-body.interceptor';
-export * from './set-create-by-on-body.interceptor';
-export * from './set-delete-by-on-body.interceptor';
-export * from './set-update-by-on-body.interceptor';
 export * from './slug.interceptor';

package/fesm/interceptors/set-user-field-on-body.interceptor.js

@@ -34,3 +34,6 @@ import { Injectable } from '@nestjs/common';
     ], SetUserFieldOnBody);
     return SetUserFieldOnBody;
 }
+/** Sets createdById field on request body from authenticated user */ export const SetCreatedByOnBody = createSetUserFieldInterceptor('createdById');
+/** Sets updatedById field on request body from authenticated user */ export const SetUpdateByOnBody = createSetUserFieldInterceptor('updatedById');
+/** Sets deletedById field on request body from authenticated user */ export const SetDeletedByOnBody = createSetUserFieldInterceptor('deletedById');

package/fesm/middlewares/logger.middleware.js

@@ -43,14 +43,6 @@ 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 = {};
@@ -72,84 +64,62 @@ 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));
             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);
@@ -161,13 +131,12 @@ export 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`,
@@ -175,33 +144,31 @@ export 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", winstonLogger);
     }

package/fesm/modules/datasource/datasource.module.js

@@ -77,24 +77,12 @@ export class DataSourceModule {
                     provide: options.useClass,
                     useClass: options.useClass
                 },
-                {
-                    provide: MODULE_OPTIONS,
-                    useFactory: async (factory)=>factory.createOptions(),
-                    inject: [
-                        options.useClass
-                    ]
-                }
+                this.createFactoryProvider(options.useClass)
             ];
         }
         if (options.useExisting) {
             return [
-                {
-                    provide: MODULE_OPTIONS,
-                    useFactory: async (factory)=>factory.createOptions(),
-                    inject: [
-                        options.useExisting
-                    ]
-                }
+                this.createFactoryProvider(options.useExisting)
             ];
         }
         return [
@@ -104,6 +92,15 @@ export class DataSourceModule {
             }
         ];
     }
+    static createFactoryProvider(factoryClass) {
+        return {
+            provide: MODULE_OPTIONS,
+            useFactory: async (factory)=>factory.createOptions(),
+            inject: [
+                factoryClass
+            ]
+        };
+    }
 }
 DataSourceModule = _ts_decorate([
     Module({})

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

@@ -90,10 +90,6 @@ export 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/fesm/modules/utils/utils.service.js

@@ -18,39 +18,25 @@ function _ts_decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 import { Injectable, Logger } from '@nestjs/common';
-import { isEmail } from 'class-validator';
-/** Default phone regex for Bangladesh (+880) */ export const DEFAULT_PHONE_REGEX = /^((\+880)|0)?(13|15|16|17|18|19)\d{8}$/;
-/** Default phone country code */ export const DEFAULT_PHONE_COUNTRY_CODE = '+88';
 export 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));
         }
@@ -58,49 +44,15 @@ export 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 (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
@@ -108,43 +60,21 @@ export 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;
-    }
-    /**
-   * Generate 4-digit OTP code
-   */ getRandomOtpCode() {
-        return Math.floor(Math.random() * (9999 - 1000 + 1)) + 1000;
+    // ---------------- PRIVATE HELPERS ----------------
+    buildTenantPrefix(tenantId) {
+        return tenantId ? `tenant_${tenantId}_` : '';
     }
-    // ---------------- 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 Logger(UtilsService.name));
-        _define_property(this, "phoneConfig", {
-            regex: DEFAULT_PHONE_REGEX,
-            countryCode: DEFAULT_PHONE_COUNTRY_CODE
-        });
     }
 }
 UtilsService = _ts_decorate([

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

@@ -1,5 +1,3 @@
-import { HttpStatus } from '@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',
@@ -8,81 +6,25 @@ import { HttpStatus } from '@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
-];
 /**
  * Error handling utility for consistent error logging and handling.
- * Provides production-aware error sanitization to prevent sensitive data leakage.
  */ export 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 = 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]';
@@ -98,7 +40,6 @@ import { HttpStatus } from '@nestjs/common';
     }
     /**
    * Create error context object for internal logging.
-   * Context data is sanitized to redact sensitive fields.
    */ static createErrorContext(error, context) {
         const errorContext = {
             error: {
@@ -110,29 +51,32 @@ import { HttpStatus } from '@nestjs/common';
             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/fesm/utils/html-sanitizer.util.js

@@ -33,7 +33,7 @@
     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]);
 }
 /**
  * Escapes all string values in a variables object for safe HTML interpolation.
@@ -67,16 +67,3 @@
     }
     return escaped;
 }
-/**
- * Checks if a string contains potential HTML/script injection.
- * Useful for logging or validation purposes.
- *
- * @param str - The string to check
- * @returns True if the string contains HTML-like content
- */ export 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/fesm/utils/index.js

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