@flusys/nestjs-shared 1.0.0-beta → 1.0.0

package/cjs/interceptors/slug.interceptor.js

@@ -29,26 +29,47 @@ 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);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
 let Slug = class Slug {
     intercept(context, next) {
         const request = context.switchToHttp().getRequest();
         if (Array.isArray(request.body)) {
-            request.body = request.body.map((item)=>({
-                    ...item,
-                    slug: item.slug || (item?.name ? this.utilsService.transformToSlug(item.name) : null)
-                }));
-        } else if (!request.body.slug) {
+            request.body = request.body.map((item)=>{
+                // Only generate slug if not provided and name exists
+                if (!item.slug && item?.name) {
+                    return {
+                        ...item,
+                        slug: this.utilsService.transformToSlug(item.name)
+                    };
+                }
+                return item;
+            });
+        } else if (!request.body?.slug && request.body?.name) {
+            // Only generate slug if not provided and name exists
             request.body = {
                 ...request.body,
-                slug: request.body?.name ? this.utilsService.transformToSlug(request.body?.name) : null
+                slug: this.utilsService.transformToSlug(request.body.name)
             };
         }
         return next.handle();
     }
-    constructor(){
-        _define_property(this, "utilsService", new _utilsservice.UtilsService());
+    constructor(utilsService){
+        _define_property(this, "utilsService", void 0);
+        this.utilsService = utilsService;
     }
 };
 Slug = _ts_decorate([
-    (0, _common.Injectable)()
+    (0, _common.Injectable)(),
+    _ts_param(0, (0, _common.Inject)(_utilsservice.UtilsService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _utilsservice.UtilsService === "undefined" ? Object : _utilsservice.UtilsService
+    ])
 ], Slug);

package/cjs/interfaces/datasource.interface.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/cjs/interfaces/index.js

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 _export_star(require("./api.interface"), exports);
-_export_star(require("./base-query.interface"), exports);
+_export_star(require("./datasource.interface"), exports);
 _export_star(require("./identity.interface"), exports);
 _export_star(require("./logged-user-info.interface"), exports);
 _export_star(require("./logger.interface"), exports);
+_export_star(require("./module-config.interface"), exports);
 _export_star(require("./permission.interface"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {

package/cjs/interfaces/module-config.interface.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

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/cache/cache.module.js

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "CacheModule", {
         return CacheModule;
     }
 });
-const _classes = require("@flusys/nestjs-shared/classes");
-const _constants = require("@flusys/nestjs-shared/constants");
+const _hybridcacheclass = require("../../classes/hybrid-cache.class");
+const _constants = require("../../constants");
 const _common = require("@nestjs/common");
 function _ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -25,7 +25,7 @@ let CacheModule = class CacheModule {
             providers: [
                 {
                     provide: _constants.CACHE_INSTANCE,
-                    useFactory: ()=>new _classes.HybridCache(memoryTtl, memorySize)
+                    useFactory: ()=>new _hybridcacheclass.HybridCache(memoryTtl, memorySize)
                 }
             ],
             exports: [

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

@@ -42,7 +42,6 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let MultiTenantDataSourceService = class MultiTenantDataSourceService {
-    // Initialization
     initializeFromOptions() {
         if (!this.options) return;
         if (!MultiTenantDataSourceService.initialized) {
@@ -55,100 +54,57 @@ let MultiTenantDataSourceService = 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 _common.BadRequestException('Invalid tenant ID format. Only alphanumeric characters, hyphens, and underscores are allowed.');
+            throw new _common.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 {
@@ -160,22 +116,14 @@ let MultiTenantDataSourceService = 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();
@@ -183,16 +131,12 @@ let MultiTenantDataSourceService = 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;
@@ -236,20 +180,11 @@ let MultiTenantDataSourceService = 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);
@@ -262,18 +197,12 @@ let MultiTenantDataSourceService = 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,
@@ -283,15 +212,7 @@ let MultiTenantDataSourceService = 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 _typeorm.DataSource({
             type: config.type,
             host: config.host,
@@ -303,16 +224,13 @@ let MultiTenantDataSourceService = class MultiTenantDataSourceService {
             synchronize: false,
             namingStrategy: new _typeormnamingstrategies.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;
@@ -321,12 +239,10 @@ let MultiTenantDataSourceService = 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([