@flusys/nestjs-shared 1.0.0-beta → 1.0.0

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

@@ -32,7 +32,6 @@ import { Request } from 'express';
 import { DataSource } from 'typeorm';
 import { SnakeNamingStrategy } from 'typeorm-naming-strategies';
 export class MultiTenantDataSourceService {
-    // Initialization
     initializeFromOptions() {
         if (!this.options) return;
         if (!MultiTenantDataSourceService.initialized) {
@@ -45,100 +44,57 @@ export class MultiTenantDataSourceService {
             MultiTenantDataSourceService.tenantsRegistry.set(tenant.id, tenant);
         });
     }
-    // Public API
-    /**
-   * Set custom tenant header name
-   */ setTenantHeader(header) {
+    setTenantHeader(header) {
         this.tenantHeader = header;
     }
-    /**
-   * Get current database mode
-   */ getDatabaseMode() {
+    getDatabaseMode() {
         return this.options?.bootstrapAppConfig?.databaseMode ?? 'single';
     }
-    /**
-   * Check if running in multi-tenant mode
-   */ isMultiTenant() {
+    isMultiTenant() {
         return this.getDatabaseMode() === 'multi-tenant';
     }
-    // Tenant Resolution
-    /**
-   * Get current tenant ID from request header
-   * Validates tenant ID format for security (alphanumeric, hyphens, underscores only)
-   */ getCurrentTenantId() {
+    getCurrentTenantId() {
         if (!this.request) return null;
         const tenantId = this.request.headers[this.tenantHeader];
         if (!tenantId) return null;
-        // Validate tenant ID format to prevent injection attacks
         if (!/^[a-zA-Z0-9_-]+$/.test(tenantId)) {
-            throw new BadRequestException('Invalid tenant ID format. Only alphanumeric characters, hyphens, and underscores are allowed.');
+            throw new BadRequestException('Invalid tenant ID format');
         }
         return tenantId;
     }
-    /**
-   * Get current tenant config from request header
-   */ getCurrentTenant() {
+    getCurrentTenant() {
         const tenantId = this.getCurrentTenantId();
         return tenantId ? this.getTenant(tenantId) : null;
     }
-    /**
-   * Get tenant config by ID
-   */ getTenant(tenantId) {
+    getTenant(tenantId) {
         return MultiTenantDataSourceService.tenantsRegistry.get(tenantId) ?? null;
     }
-    /**
-   * Get all registered tenants
-   */ getAllTenants() {
+    getAllTenants() {
         return Array.from(MultiTenantDataSourceService.tenantsRegistry.values());
     }
-    /**
-   * Get only active tenants
-   */ getActiveTenants() {
+    getActiveTenants() {
         return this.getAllTenants();
     }
-    // DataSource Access
-    /**
-   * Get DataSource for current context (tenant or single)
-   */ async getDataSource() {
+    async getDataSource() {
         return this.isMultiTenant() ? this.getTenantDataSource() : this.getSingleDataSource();
     }
-    /**
-   * Get DataSource for specific tenant
-   */ async getDataSourceForTenant(tenantId) {
+    async getDataSourceForTenant(tenantId) {
         const tenant = this.getTenant(tenantId);
-        if (!tenant) {
-            throw new Error(`Tenant '${tenantId}' not found`);
-        }
+        if (!tenant) throw new Error(`Tenant '${tenantId}' not found`);
         return this.getOrCreateTenantConnection(tenant);
     }
-    /**
-   * Set external DataSource (for single-tenant mode)
-   */ setDataSource(dataSource) {
+    setDataSource(dataSource) {
         MultiTenantDataSourceService.singleDataSource = dataSource;
     }
-    // Repository Access
-    /**
-   * Get repository for entity in current context
-   */ async getRepository(entity) {
+    async getRepository(entity) {
         const dataSource = await this.getDataSource();
         return dataSource.getRepository(entity);
     }
-    /**
-   * Get repository for entity in specific tenant
-   */ async getRepositoryForTenant(entity, tenantId) {
-        const dataSource = await this.getDataSourceForTenant(tenantId);
-        return dataSource.getRepository(entity);
-    }
-    // Multi-Tenant Operations
-    /**
-   * Execute callback with specific tenant's DataSource
-   */ async withTenant(tenantId, callback) {
+    async withTenant(tenantId, callback) {
         const dataSource = await this.getDataSourceForTenant(tenantId);
         return callback(dataSource);
     }
-    /**
-   * Execute callback for all active tenants
-   */ async forAllTenants(callback) {
+    async forAllTenants(callback) {
         const results = new Map();
         for (const tenant of this.getActiveTenants()){
             try {
@@ -150,22 +106,14 @@ export class MultiTenantDataSourceService {
         }
         return results;
     }
-    // Tenant Management
-    /**
-   * Register a new tenant at runtime
-   */ registerTenant(tenant) {
+    registerTenant(tenant) {
         MultiTenantDataSourceService.tenantsRegistry.set(tenant.id, tenant);
     }
-    /**
-   * Remove tenant and close its connection
-   */ async removeTenant(tenantId) {
+    async removeTenant(tenantId) {
         await this.closeTenantConnection(tenantId);
         MultiTenantDataSourceService.tenantsRegistry.delete(tenantId);
     }
-    // Connection Lifecycle
-    /**
-   * Close specific tenant connection
-   */ async closeTenantConnection(tenantId) {
+    async closeTenantConnection(tenantId) {
         const connection = MultiTenantDataSourceService.tenantConnections.get(tenantId);
         if (connection?.isInitialized) {
             await connection.destroy();
@@ -173,16 +121,12 @@ export class MultiTenantDataSourceService {
             this.logger.log(`Closed connection for tenant: ${tenantId}`);
         }
     }
-    /**
-   * Lifecycle hook - cleanup on module destroy
-   */ async onModuleDestroy() {
+    async onModuleDestroy() {
         for (const [tenantId] of MultiTenantDataSourceService.tenantConnections){
             await this.closeTenantConnection(tenantId);
         }
     }
-    /**
-   * Reset all static state (useful for testing)
-   */ static reset() {
+    static reset() {
         MultiTenantDataSourceService.initialized = false;
         MultiTenantDataSourceService.singleDataSource = null;
         MultiTenantDataSourceService.singleConnectionLock = null;
@@ -226,20 +170,11 @@ export class MultiTenantDataSourceService {
         }
         return this.getOrCreateTenantConnection(tenant);
     }
-    /**
-   * Get or create connection for tenant with locking to prevent race conditions
-   */ async getOrCreateTenantConnection(tenant) {
-        // Return existing initialized connection
+    async getOrCreateTenantConnection(tenant) {
         const existing = MultiTenantDataSourceService.tenantConnections.get(tenant.id);
-        if (existing?.isInitialized) {
-            return existing;
-        }
-        // If another request is creating this tenant's connection, wait for it
+        if (existing?.isInitialized) return existing;
         const pendingConnection = MultiTenantDataSourceService.connectionLocks.get(tenant.id);
-        if (pendingConnection) {
-            return pendingConnection;
-        }
-        // Create connection with lock to prevent race conditions
+        if (pendingConnection) return pendingConnection;
         const config = this.buildTenantDatabaseConfig(tenant);
         const connectionPromise = this.createDataSourceFromConfig(config);
         MultiTenantDataSourceService.connectionLocks.set(tenant.id, connectionPromise);
@@ -252,18 +187,12 @@ export class MultiTenantDataSourceService {
             MultiTenantDataSourceService.connectionLocks.delete(tenant.id);
         }
     }
-    /**
-   * Get default database config (supports both naming conventions)
-   */ getDefaultDatabaseConfig() {
+    getDefaultDatabaseConfig() {
         return this.options?.defaultDatabaseConfig ?? this.options?.tenantDefaultDatabaseConfig;
     }
-    /**
-   * Build database config for tenant (merges with default)
-   */ buildTenantDatabaseConfig(tenant) {
+    buildTenantDatabaseConfig(tenant) {
         const defaultConfig = this.getDefaultDatabaseConfig();
-        if (!defaultConfig) {
-            throw new Error('No default database config for multi-tenant mode.');
-        }
+        if (!defaultConfig) throw new Error('No default database config for multi-tenant mode.');
         return {
             type: defaultConfig.type,
             host: tenant.host ?? defaultConfig.host,
@@ -273,15 +202,7 @@ export class MultiTenantDataSourceService {
             database: tenant.database
         };
     }
-    /**
-   * Create DataSource from config - override in subclasses for custom logic
-   *
-   * Note: In multi-tenant mode, subclasses should pass entities array.
-   * For single-tenant mode, entities are registered via TypeOrmModule at app level.
-   *
-   * @param config - Database configuration
-   * @param entities - Optional entities array (for multi-tenant mode)
-   */ async createDataSourceFromConfig(config, entities = []) {
+    async createDataSourceFromConfig(config, entities = []) {
         const dataSource = new DataSource({
             type: config.type,
             host: config.host,
@@ -293,16 +214,13 @@ export class MultiTenantDataSourceService {
             synchronize: false,
             namingStrategy: new SnakeNamingStrategy()
         });
-        if (!dataSource.isInitialized) {
-            await dataSource.initialize();
-        }
+        if (!dataSource.isInitialized) await dataSource.initialize();
         return dataSource;
     }
     constructor(options, request){
         _define_property(this, "options", void 0);
         _define_property(this, "request", void 0);
         _define_property(this, "logger", void 0);
-        // Instance state
         _define_property(this, "tenantHeader", void 0);
         this.options = options;
         this.request = request;
@@ -311,12 +229,10 @@ export class MultiTenantDataSourceService {
         this.initializeFromOptions();
     }
 }
-// Static state shared across all instances
 _define_property(MultiTenantDataSourceService, "tenantConnections", new Map());
 _define_property(MultiTenantDataSourceService, "singleDataSource", null);
 _define_property(MultiTenantDataSourceService, "tenantsRegistry", new Map());
 _define_property(MultiTenantDataSourceService, "initialized", false);
-// Connection locks to prevent race conditions during concurrent connection creation
 _define_property(MultiTenantDataSourceService, "connectionLocks", new Map());
 _define_property(MultiTenantDataSourceService, "singleConnectionLock", null);
 MultiTenantDataSourceService = _ts_decorate([

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

@@ -1,245 +1,82 @@
+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;
 }
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-import { Injectable } from '@nestjs/common';
-import { isEmail } from 'class-validator';
+import { Injectable, Logger } from '@nestjs/common';
 export class UtilsService {
     // ---------------- CACHE HELPERS ----------------
     /**
    * Generate cache key with optional tenant prefix for multi-tenant isolation
-   * @param entityName - Name of the entity being cached
-   * @param params - Query parameters for cache key uniqueness
-   * @param entityId - Optional entity ID for single entity caching
-   * @param tenantId - Optional tenant ID 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) {
-            // Log but don't throw - cache tracking failure shouldn't break the request
-            console.error(`Cache tracking failed for ${entityName}:`, error);
+            this.logger.error(`Cache tracking failed for ${entityName}`, error instanceof Error ? error.stack : String(error));
         }
     }
     /**
    * Clear cache for entity with optional tenant prefix
-   * Uses Promise.allSettled to ensure all deletions are attempted even if some fail
    */ 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) || [];
-                // Use Promise.allSettled to ensure all deletions are attempted
-                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) || [];
-                // Use Promise.allSettled to ensure all deletions are attempted
-                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) {
-            // Log but don't throw - cache invalidation failure shouldn't break the request
-            console.error(`Cache invalidation failed for ${entityName}:`, error);
-        }
-    }
-    /**
-   * Check Phone or Email
-   */ checkPhoneOrEmail(value) {
-        if (isEmail(value)) {
-            return {
-                value: value,
-                type: 'email'
-            };
-        }
-        const phoneMatch = value.match(/^((\+880)|0)?(13|15|16|17|18|19)\d{8}$/);
-        if (phoneMatch) {
-            let phone = phoneMatch[0];
-            if (!phone.startsWith('+88')) {
-                phone = '+88' + phone;
-            }
-            return {
-                value: phone,
-                type: 'phone'
-            };
+            this.logger.error(`Cache invalidation failed for ${entityName}`, error instanceof Error ? error.stack : String(error));
         }
-        return {
-            value: null,
-            type: null
-        };
     }
+    // ---------------- STRING HELPERS ----------------
     /**
-   * STRING FUNCTIONS
-   * transformToSlug
+   * Transform string to URL-friendly slug
    */ transformToSlug(value, salt) {
         const slug = value?.trim().replace(/[^A-Z0-9]+/gi, '-').toLowerCase();
         return salt ? `${slug}-${this.getRandomInt(1, 100)}` : slug;
     }
     /**
-   * RANDOM FUNCTIONS
-   * getRandomInt
-   * generateRandomId
-   * getRandomOtpCode
+   * Generate random integer between min and max (inclusive)
    */ getRandomInt(min, max) {
         return Math.floor(Math.random() * (max - min + 1)) + min;
     }
-    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;
-    }
-    getRandomOtpCode() {
-        return Math.floor(Math.random() * (9999 - 1000 + 1)) + 1000;
+    // ---------------- PRIVATE HELPERS ----------------
+    buildTenantPrefix(tenantId) {
+        return tenantId ? `tenant_${tenantId}_` : '';
     }
-    extractColumnNameFromError(detail) {
-        const match = detail.match(/\((.*?)\)=\((.*?)\)/);
-        return {
-            columnName: match ? match[1] : 'unknown',
-            value: match ? match[2] : 'unknown'
-        };
-    }
-    getOtpEmailFormat(otp, userName) {
-        return `
-    <!DOCTYPE html>
-    <html lang="en">
-    <head>
-      <meta charset="UTF-8" />
-      <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
-      <title>Your OTP Code</title>
-      <style>
-        body {
-          font-family: Arial, sans-serif;
-          background-color: #f4f4f7;
-          margin: 0;
-          padding: 0;
-        }
-        .email-container {
-          max-width: 500px;
-          margin: 40px auto;
-          background-color: #ffffff;
-          padding: 30px;
-          border-radius: 8px;
-          box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);
-          text-align: center;
-        }
-        h1 {
-          color: #333;
-        }
-        p {
-          font-size: 16px;
-          color: #555;
-        }
-        .otp-box {
-          display: inline-block;
-          margin: 20px 0;
-          padding: 14px 28px;
-          font-size: 24px;
-          letter-spacing: 6px;
-          background-color: #007BFF;
-          color: white;
-          border-radius: 8px;
-          font-weight: bold;
-        }
-      </style>
-    </head>
-    <body>
-      <div class="email-container">
-        <p>Hi ${userName || 'Sir/Madam'},</p>
-        <p>Use the code below to verify your identity:</p>
-        <div class="otp-box">${otp}</div>
-        <p>This OTP is valid for a limited time. Do not share it with anyone.</p>
-        <p>If you didn’t request this, please ignore this email.</p>
-      </div>
-    </body>
-    </html>
-  `;
+    buildTrackingKey(entityName, entityId, tenantId) {
+        const prefix = this.buildTenantPrefix(tenantId);
+        return entityId ? `${prefix}entity_${entityName}_id_${entityId}_keys` : `${prefix}entity_${entityName}_keys`;
     }
-    getResetPasswordEmailFormat(resetLink, userName) {
-        return `
-  <!DOCTYPE html>
-  <html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
-    <title>Reset Your Password</title>
-    <style>
-      body {
-        font-family: Arial, sans-serif;
-        background-color: #f4f4f7;
-        margin: 0;
-        padding: 0;
-      }
-      .email-container {
-        max-width: 500px;
-        margin: 40px auto;
-        background-color: #ffffff;
-        padding: 30px;
-        border-radius: 8px;
-        box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);
-        text-align: center;
-      }
-      h1 {
-        color: #333;
-      }
-      p {
-        font-size: 16px;
-        color: #555;
-      }
-      .reset-button {
-        display: inline-block;
-        margin: 20px 0;
-        padding: 14px 28px;
-        font-size: 16px;
-        background-color: #007BFF;
-        color: #ffffff !important;
-        text-decoration: none;
-        border-radius: 6px;
-        font-weight: bold;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="email-container">
-      <p>Hi ${userName || 'Sir/Madam'},</p>
-      <p>We received a request to reset your password. Click the button below to reset it:</p>
-      <a href="${resetLink}" class="reset-button" target="_blank">Reset Password</a>
-      <p>If you didn’t request a password reset, you can safely ignore this email.</p>
-    </div>
-  </body>
-  </html>
-  `;
+    constructor(){
+        _define_property(this, "logger", new Logger(UtilsService.name));
     }
-    constructor(){}
 }
 UtilsService = _ts_decorate([
-    Injectable(),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [])
+    Injectable()
 ], UtilsService);

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

@@ -1,8 +1,16 @@
+/** Sensitive keys that should be redacted from logs */ const SENSITIVE_KEYS = [
+    'password',
+    'secret',
+    'token',
+    'apiKey',
+    'credential',
+    'authorization'
+];
 /**
- * Error handling utility for consistent error logging and handling
+ * Error handling utility for consistent error logging and handling.
  */ export class ErrorHandler {
     /**
-   * Safely extract error message from unknown error
+   * Safely extract error message from unknown error.
    */ static getErrorMessage(error) {
         if (error instanceof Error) {
             return error.message;
@@ -13,15 +21,25 @@
         return 'Unknown error occurred';
     }
     /**
-   * Safely extract error stack from unknown error
-   */ static getErrorStack(error) {
-        if (error instanceof Error) {
-            return error.stack;
+   * Sanitize context data to redact sensitive fields from logs.
+   */ static sanitizeContextForLogging(context) {
+        const sanitized = {};
+        for (const [key, value] of Object.entries(context)){
+            const isSensitive = SENSITIVE_KEYS.some((sk)=>key.toLowerCase().includes(sk.toLowerCase()));
+            if (isSensitive) {
+                sanitized[key] = '[REDACTED]';
+            } else if (Array.isArray(value)) {
+                sanitized[key] = value.map((item)=>typeof item === 'object' && item !== null ? this.sanitizeContextForLogging(item) : item);
+            } else if (typeof value === 'object' && value !== null) {
+                sanitized[key] = this.sanitizeContextForLogging(value);
+            } else {
+                sanitized[key] = value;
+            }
         }
-        return undefined;
+        return sanitized;
     }
     /**
-   * Create error context object for logging
+   * Create error context object for internal logging.
    */ static createErrorContext(error, context) {
         const errorContext = {
             error: {
@@ -33,27 +51,32 @@
             errorContext.error.name = error.name;
         }
         if (context && Object.keys(context).length > 0) {
-            errorContext.context = context;
+            errorContext.context = this.sanitizeContextForLogging(context);
         }
         return errorContext;
     }
     /**
-   * Log error with consistent format
+   * Log error with consistent format.
    */ static logError(logger, error, operation, context) {
         const errorContext = this.createErrorContext(error, {
             operation,
             ...context
         });
         const errorMessage = `Failed to ${operation}: ${errorContext.error.message}`;
-        const loggerContext = logger.context || 'ErrorHandler';
-        logger.error(errorMessage, errorContext.error.stack, loggerContext, errorContext);
+        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);
+    }
 }