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

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

@@ -26,243 +26,135 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { DEFAULT_TENANT_HEADER, IDataSourceServiceOptions, MODULE_OPTIONS } from '@flusys/nestjs-core';
-import { BadRequestException, Inject, Injectable, Logger, Optional, Scope } from '@nestjs/common';
+import { BadRequestException, Inject, Injectable, InternalServerErrorException, Optional, Scope } from '@nestjs/common';
+import { SYSTEM_MESSAGES } from '../../constants';
 import { REQUEST } from '@nestjs/core';
 import { Request } from 'express';
 import { DataSource } from 'typeorm';
 import { SnakeNamingStrategy } from 'typeorm-naming-strategies';
 export class MultiTenantDataSourceService {
-    // Initialization
+    get self() {
+        return this.constructor;
+    }
     initializeFromOptions() {
         if (!this.options) return;
-        if (!MultiTenantDataSourceService.initialized) {
+        if (!this.self.initialized) {
             this.registerTenants();
-            MultiTenantDataSourceService.initialized = true;
+            this.self.initialized = true;
         }
     }
     registerTenants() {
         this.options?.tenants?.forEach((tenant)=>{
-            MultiTenantDataSourceService.tenantsRegistry.set(tenant.id, tenant);
+            this.self.tenantsRegistry.set(tenant.id, tenant);
         });
     }
-    // Public API
-    /**
-   * Set custom tenant header name
-   */ 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({
+                message: 'Invalid tenant ID format',
+                messageKey: SYSTEM_MESSAGES.INVALID_TENANT_ID
+            });
         }
         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) {
-        return MultiTenantDataSourceService.tenantsRegistry.get(tenantId) ?? null;
-    }
-    /**
-   * Get all registered tenants
-   */ getAllTenants() {
-        return Array.from(MultiTenantDataSourceService.tenantsRegistry.values());
+    getTenant(tenantId) {
+        return this.self.tenantsRegistry.get(tenantId) ?? null;
     }
-    /**
-   * Get only active tenants
-   */ 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) {
-        const tenant = this.getTenant(tenantId);
-        if (!tenant) {
-            throw new Error(`Tenant '${tenantId}' not found`);
-        }
-        return this.getOrCreateTenantConnection(tenant);
-    }
-    /**
-   * Set external DataSource (for single-tenant mode)
-   */ 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) {
-        const dataSource = await this.getDataSourceForTenant(tenantId);
-        return callback(dataSource);
-    }
-    /**
-   * Execute callback for all active tenants
-   */ async forAllTenants(callback) {
-        const results = new Map();
-        for (const tenant of this.getActiveTenants()){
-            try {
-                const dataSource = await this.getOrCreateTenantConnection(tenant);
-                results.set(tenant.id, await callback(tenant, dataSource));
-            } catch (error) {
-                this.logger.error(`Error processing tenant ${tenant.id}: ${error}`);
-            }
-        }
-        return results;
-    }
-    // Tenant Management
-    /**
-   * Register a new tenant at runtime
-   */ registerTenant(tenant) {
-        MultiTenantDataSourceService.tenantsRegistry.set(tenant.id, tenant);
-    }
-    /**
-   * Remove tenant and close its connection
-   */ async removeTenant(tenantId) {
-        await this.closeTenantConnection(tenantId);
-        MultiTenantDataSourceService.tenantsRegistry.delete(tenantId);
-    }
-    // Connection Lifecycle
-    /**
-   * Close specific tenant connection
-   */ async closeTenantConnection(tenantId) {
-        const connection = MultiTenantDataSourceService.tenantConnections.get(tenantId);
+    async closeTenantConnection(tenantId) {
+        const connection = this.self.tenantConnections.get(tenantId);
         if (connection?.isInitialized) {
             await connection.destroy();
-            MultiTenantDataSourceService.tenantConnections.delete(tenantId);
-            this.logger.log(`Closed connection for tenant: ${tenantId}`);
+            this.self.tenantConnections.delete(tenantId);
         }
     }
-    /**
-   * Lifecycle hook - cleanup on module destroy
-   */ async onModuleDestroy() {
-        for (const [tenantId] of MultiTenantDataSourceService.tenantConnections){
+    async onModuleDestroy() {
+        for (const [tenantId] of this.self.tenantConnections){
             await this.closeTenantConnection(tenantId);
         }
     }
-    /**
-   * Reset all static state (useful for testing)
-   */ static reset() {
-        MultiTenantDataSourceService.initialized = false;
-        MultiTenantDataSourceService.singleDataSource = null;
-        MultiTenantDataSourceService.singleConnectionLock = null;
-        MultiTenantDataSourceService.tenantConnections.clear();
-        MultiTenantDataSourceService.tenantsRegistry.clear();
-        MultiTenantDataSourceService.connectionLocks.clear();
-    }
-    // Protected Methods (for subclasses)
-    /**
-   * Get single database DataSource with connection locking to prevent race conditions
-   */ async getSingleDataSource() {
-        // Return existing initialized connection
-        if (MultiTenantDataSourceService.singleDataSource?.isInitialized) {
-            return MultiTenantDataSourceService.singleDataSource;
+    async getSingleDataSource() {
+        if (this.self.singleDataSource?.isInitialized) {
+            return this.self.singleDataSource;
         }
-        // If another request is creating the connection, wait for it
-        if (MultiTenantDataSourceService.singleConnectionLock) {
-            return MultiTenantDataSourceService.singleConnectionLock;
+        if (this.self.singleConnectionLock) {
+            return this.self.singleConnectionLock;
         }
         const config = this.getDefaultDatabaseConfig();
         if (!config) {
-            throw new Error('No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.');
+            throw new InternalServerErrorException({
+                message: 'No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.',
+                messageKey: SYSTEM_MESSAGES.DATABASE_CONFIG_NOT_AVAILABLE
+            });
         }
-        // Create connection with lock to prevent race conditions
         const connectionPromise = this.createDataSourceFromConfig(config);
-        MultiTenantDataSourceService.singleConnectionLock = connectionPromise;
+        this.self.singleConnectionLock = connectionPromise;
         try {
             const dataSource = await connectionPromise;
-            MultiTenantDataSourceService.singleDataSource = dataSource;
+            this.self.singleDataSource = dataSource;
             return dataSource;
         } finally{
-            MultiTenantDataSourceService.singleConnectionLock = null;
+            this.self.singleConnectionLock = null;
         }
     }
-    /**
-   * Get tenant-specific DataSource
-   */ async getTenantDataSource() {
+    async getTenantDataSource() {
         const tenant = this.getCurrentTenant();
         if (!tenant) {
-            throw new Error(`Tenant not found. Ensure '${this.tenantHeader}' header is set.`);
+            throw new BadRequestException({
+                message: `Tenant not found. Ensure '${this.tenantHeader}' header is set.`,
+                messageKey: SYSTEM_MESSAGES.TENANT_HEADER_REQUIRED,
+                messageVariables: {
+                    header: this.tenantHeader
+                }
+            });
         }
         return this.getOrCreateTenantConnection(tenant);
     }
-    /**
-   * Get or create connection for tenant with locking to prevent race conditions
-   */ async getOrCreateTenantConnection(tenant) {
-        // Return existing initialized connection
-        const existing = MultiTenantDataSourceService.tenantConnections.get(tenant.id);
-        if (existing?.isInitialized) {
-            return existing;
-        }
-        // If another request is creating this tenant's connection, wait for it
-        const pendingConnection = MultiTenantDataSourceService.connectionLocks.get(tenant.id);
-        if (pendingConnection) {
-            return pendingConnection;
-        }
-        // Create connection with lock to prevent race conditions
+    async getOrCreateTenantConnection(tenant) {
+        const existing = this.self.tenantConnections.get(tenant.id);
+        if (existing?.isInitialized) return existing;
+        const pendingConnection = this.self.connectionLocks.get(tenant.id);
+        if (pendingConnection) return pendingConnection;
         const config = this.buildTenantDatabaseConfig(tenant);
         const connectionPromise = this.createDataSourceFromConfig(config);
-        MultiTenantDataSourceService.connectionLocks.set(tenant.id, connectionPromise);
+        this.self.connectionLocks.set(tenant.id, connectionPromise);
         try {
             const dataSource = await connectionPromise;
-            MultiTenantDataSourceService.tenantConnections.set(tenant.id, dataSource);
-            this.logger.log(`Created connection for tenant: ${tenant.id}`);
+            this.self.tenantConnections.set(tenant.id, dataSource);
             return dataSource;
         } finally{
-            MultiTenantDataSourceService.connectionLocks.delete(tenant.id);
+            this.self.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.');
+            throw new InternalServerErrorException({
+                message: 'No default database config for multi-tenant mode.',
+                messageKey: SYSTEM_MESSAGES.DATABASE_CONFIG_NOT_AVAILABLE
+            });
         }
         return {
             type: defaultConfig.type,
@@ -273,15 +165,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,30 +177,23 @@ 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;
-        this.logger = new Logger(this.constructor.name);
         this.tenantHeader = DEFAULT_TENANT_HEADER;
         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

@@ -4,242 +4,63 @@ 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;
 }
-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';
 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);
-            }
-        } catch (error) {
-            // Log but don't throw - cache tracking failure shouldn't break the request
-            console.error(`Cache tracking failed for ${entityName}:`, error);
+            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  {
+        // Silent failure - cache tracking is non-critical
         }
     }
     /**
    * 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);
-            }
-        } 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'
-            };
+            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  {
+        // Silent failure - cache invalidation is non-critical
         }
-        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;
-    }
-    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>
-  `;
+    // ---------------- PRIVATE HELPERS ----------------
+    buildTenantPrefix(tenantId) {
+        return tenantId ? `tenant_${tenantId}_` : '';
     }
-    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>
-  `;
+    buildTrackingKey(entityName, entityId, tenantId) {
+        const prefix = this.buildTenantPrefix(tenantId);
+        return entityId ? `${prefix}entity_${entityName}_id_${entityId}_keys` : `${prefix}entity_${entityName}_keys`;
     }
-    constructor(){}
 }
 UtilsService = _ts_decorate([
-    Injectable(),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [])
+    Injectable()
 ], UtilsService);