@flusys/nestjs-shared 5.1.1 → 5.1.3

package/cjs/classes/api-controller.class.js

@@ -11,11 +11,11 @@ Object.defineProperty(exports, "createApiController", {
 const _common = require("@nestjs/common");
 const _swagger = require("@nestjs/swagger");
 const _classtransformer = require("class-transformer");
+const _messagekeys = require("../constants/message-keys");
 const _decorators = require("../decorators");
 const _apiresponsedecorator = require("../decorators/api-response.decorator");
 const _dtos = require("../dtos");
 const _exceptions = require("../exceptions");
-const _messagekeys = require("../constants/message-keys");
 const _guards = require("../guards");
 const _interceptors = require("../interceptors");
 function _define_property(obj, key, value) {
@@ -108,6 +108,12 @@ function _ts_param(paramIndex, decorator) {
     return (0, _common.applyDecorators)(...decorators);
 }
 function createApiController(createDtoClass, updateDtoClass, responseDtoClass, options = {}) {
+    const excludeExtraneousValues = options.excludeExtraneousValues ?? true;
+    function toDto(cls, input) {
+        return (0, _classtransformer.plainToInstance)(cls, input, {
+            excludeExtraneousValues
+        });
+    }
     // Entity name for message keys (defaults to 'item')
     const entityName = options.entityName ?? 'item';
     // Determine if security is global (applies to all) or per-endpoint
@@ -163,7 +169,7 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 });
             }
             const entity = await this.service.insert(addDto, user);
-            const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entity);
+            const data = toDto(responseDtoClass, entity);
             return {
                 success: true,
                 message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} created successfully`,
@@ -183,7 +189,7 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 });
             }
             const entities = await this.service.insertMany(addDto, user);
-            const data = entities.map((item)=>(0, _classtransformer.plainToInstance)(responseDtoClass, item));
+            const data = entities.map((item)=>toDto(responseDtoClass, item));
             return {
                 success: true,
                 message: `${data.length} ${entityName}s created successfully`,
@@ -211,7 +217,7 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 });
             }
             const entity = await this.service.findById(id, user, body?.select);
-            const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entity);
+            const data = toDto(responseDtoClass, entity);
             return {
                 success: true,
                 message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} retrieved successfully`,
@@ -231,7 +237,7 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 });
             }
             const entities = await this.service.findByIds(body.ids, user, body?.select);
-            const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entities);
+            const data = entities.map((item)=>toDto(responseDtoClass, item));
             return {
                 success: true,
                 message: `${data.length} ${entityName}${data.length !== 1 ? 's' : ''} retrieved successfully`,
@@ -258,7 +264,7 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 });
             }
             const entity = await this.service.update(updateDto, user);
-            const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entity);
+            const data = toDto(responseDtoClass, entity);
             return {
                 success: true,
                 message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} updated successfully`,
@@ -278,7 +284,7 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 });
             }
             const entities = await this.service.updateMany(updateDtos, user);
-            const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entities);
+            const data = entities.map((item)=>toDto(responseDtoClass, item));
             return {
                 success: true,
                 message: `${data.length} ${entityName}s updated successfully`,
@@ -315,7 +321,7 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 }
             }
             const allEntities = await this.service.bulkUpsert(toInsert, toUpdate, user);
-            const data = (0, _classtransformer.plainToInstance)(responseDtoClass, allEntities);
+            const data = allEntities.map((item)=>toDto(responseDtoClass, item));
             return {
                 success: true,
                 message: `${data.length} ${entityName}s upserted successfully`,
@@ -353,7 +359,7 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 throw new _exceptions.NotFoundException(entityName);
             }
             const entity = result.data[0];
-            const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entity);
+            const data = toDto(responseDtoClass, entity);
             return {
                 success: true,
                 message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} retrieved successfully`,
@@ -373,7 +379,7 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 });
             }
             const result = await this.service.getAll(search ?? '', filterAndPaginationDto, user);
-            const data = (0, _classtransformer.plainToInstance)(responseDtoClass, result.data);
+            const data = result.data.map((item)=>toDto(responseDtoClass, item));
             const page = filterAndPaginationDto.pagination?.currentPage ?? 0;
             const pageSize = filterAndPaginationDto.pagination?.pageSize ?? data.length;
             const totalPages = pageSize > 0 ? Math.ceil(result.total / pageSize) : 1;

package/cjs/classes/api-service.class.js

@@ -13,6 +13,9 @@ const _typeorm = require("typeorm");
 const _constants = require("../constants");
 const _logactiondecorator = require("../decorators/log-action.decorator");
 const _dtos = require("../dtos");
+const _interfaces = require("../interfaces");
+const _utilsservice = require("../modules/utils/utils.service");
+const _hybridcacheclass = require("./hybrid-cache.class");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -36,6 +39,31 @@ function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 let ApiService = class ApiService {
+    resolveEntity() {
+        return this._entity;
+    }
+    getDataSourceProvider() {
+        return this._dataSourceProvider;
+    }
+    async ensureDataSourceRepository() {
+        if (!this.repositoryInitialized) {
+            const entity = this.resolveEntity();
+            const provider = this.getDataSourceProvider();
+            this.repository = await provider.getRepository(entity);
+            this.repositoryInitialized = true;
+        }
+    }
+    async resolveRepositories(entities) {
+        const provider = this.getDataSourceProvider();
+        const repositories = [];
+        for (const entity of entities){
+            repositories.push(await provider.getRepository(entity));
+        }
+        return repositories;
+    }
+    async getDataSourceForService() {
+        return this.getDataSourceProvider().getDataSource();
+    }
     async insert(dto, user) {
         return this.executeInTransaction('insert', async (qr)=>{
             await this.beforeInsertOperation(dto, user, qr);
@@ -108,7 +136,7 @@ let ApiService = class ApiService {
         });
     }
     async findByIds(ids, user, select) {
-        await this.ensureRepositoryInitialized();
+        await this.ensureDataSourceRepository();
         try {
             const query = this.repository.createQueryBuilder(this.entityName);
             query.where({
@@ -136,7 +164,7 @@ let ApiService = class ApiService {
         }
     }
     async findById(id, user, select) {
-        await this.ensureRepositoryInitialized();
+        await this.ensureDataSourceRepository();
         try {
             const query = this.repository.createQueryBuilder(this.entityName);
             query.where({
@@ -150,18 +178,17 @@ let ApiService = class ApiService {
                 result = await this.cacheManager.get(cacheKey);
             }
             if (!result) {
-                let output;
                 if (isRaw) {
-                    output = await finalQuery.getRawMany();
-                    const convertResult = this.convertEntityListToResponseListDto(output, isRaw);
+                    const rawOutput = await finalQuery.getRawMany();
+                    const convertResult = this.convertEntityListToResponseListDto(rawOutput, isRaw);
                     if (convertResult.length) result = convertResult[0];
                 } else {
-                    output = await finalQuery.getOne();
-                    if (!output) throw new _common.NotFoundException({
+                    const singleOutput = await finalQuery.getOne();
+                    if (!singleOutput) throw new _common.NotFoundException({
                         message: 'No Data Found',
                         messageKey: _constants.ERROR_MESSAGES.NOT_FOUND
                     });
-                    result = this.convertEntityToResponseDto(output, false);
+                    result = this.convertEntityToResponseDto(singleOutput, false);
                 }
                 if (this.isCacheable) {
                     await this.cacheManager.set(cacheKey, result);
@@ -177,43 +204,34 @@ let ApiService = class ApiService {
         }
     }
     async getAll(search, filterAndPaginationDto, user) {
-        await this.ensureRepositoryInitialized();
+        await this.ensureDataSourceRepository();
         try {
             let data;
             let total;
             let isRaw = false;
             let query = this.repository.createQueryBuilder(this.entityName);
-            // Apply filters
             if (filterAndPaginationDto.filter) {
                 const { query: filterQuery, isRaw: filterIsRaw } = await this.getFilterQuery(query, filterAndPaginationDto.filter, user);
                 query = filterQuery;
                 isRaw = isRaw || filterIsRaw;
             }
-            // Apply search
             if (search) {
                 const { query: searchQuery, isRaw: searchIsRaw } = await this.getGlobalSearchQuery(query, search, user);
                 query = searchQuery;
                 isRaw = isRaw || searchIsRaw;
             }
-            // Apply select
-            if (filterAndPaginationDto.select) {
-                const { query: selectQuery, isRaw: selectIsRaw } = await this.getSelectQuery(query, user, filterAndPaginationDto.select);
-                query = selectQuery;
-                isRaw = isRaw || selectIsRaw;
-            }
-            // Apply sort
+            const { query: selectQuery, isRaw: selectIsRaw } = await this.getSelectQuery(query, user, filterAndPaginationDto.select);
+            query = selectQuery;
+            isRaw = isRaw || selectIsRaw;
             if (filterAndPaginationDto.sort) {
                 const { query: sortQuery, isRaw: sortIsRaw } = await this.getSortQuery(query, filterAndPaginationDto.sort, user);
                 query = sortQuery;
                 isRaw = isRaw || sortIsRaw;
             }
-            // Include soft-deleted if requested
             if (filterAndPaginationDto.withDeleted) query.withDeleted();
-            // Extra manipulation
             const { query: extraQuery, isRaw: extraIsRaw } = await this.getExtraManipulateQuery(query, filterAndPaginationDto, user);
             query = extraQuery;
             isRaw = isRaw || extraIsRaw;
-            // Pagination
             if (filterAndPaginationDto.pagination) {
                 const offset = filterAndPaginationDto.pagination.currentPage * filterAndPaginationDto.pagination.pageSize;
                 const limit = filterAndPaginationDto.pagination.pageSize;
@@ -223,7 +241,6 @@ let ApiService = class ApiService {
                     query.skip(offset).take(limit);
                 }
             }
-            // Generate cache key
             let cacheKey = '';
             if (this.isCacheable) {
                 cacheKey = this.utilsService.getCacheKey(this.entityName, {
@@ -237,7 +254,6 @@ let ApiService = class ApiService {
                 }
             }
             if (isRaw) {
-                // Handle raw query count manually
                 const rawSubQuery = query.clone().offset(undefined).limit(undefined).distinct(true);
                 const countSql = `
             SELECT COUNT(*) as count
@@ -285,7 +301,7 @@ let ApiService = class ApiService {
         }
     }
     async delete(option, user) {
-        await this.ensureRepositoryInitialized();
+        await this.ensureDataSourceRepository();
         const queryRunner = this.repository.manager.connection.createQueryRunner();
         await queryRunner.connect();
         await queryRunner.startTransaction();
@@ -317,7 +333,6 @@ let ApiService = class ApiService {
                 this.clearCacheForAll(),
                 this.clearCacheForId(ids)
             ]);
-            // return null per IService contract
             return null;
         } catch (error) {
             await queryRunner.rollbackTransaction();
@@ -326,7 +341,6 @@ let ApiService = class ApiService {
             await queryRunner.release();
         }
     }
-    // Caching
     async clearCacheForAll() {
         await this.utilsService.clearCache(this.entityName, this.cacheManager);
     }
@@ -342,13 +356,13 @@ let ApiService = class ApiService {
             messageKey: _constants.ERROR_MESSAGES.INTERNAL
         });
     }
-    /** Ensures value is always an array */ ensureArray(value) {
+    ensureArray(value) {
         return Array.isArray(value) ? value : [
             value
         ];
     }
-    /** Executes operation in transaction with automatic cache clearing */ async executeInTransaction(operation, fn) {
-        await this.ensureRepositoryInitialized();
+    async executeInTransaction(operation, fn) {
+        await this.ensureDataSourceRepository();
         const qr = this.repository.manager.connection.createQueryRunner();
         await qr.connect();
         await qr.startTransaction();
@@ -373,8 +387,6 @@ let ApiService = class ApiService {
             await qr.release();
         }
     }
-    // Hooks (override in child classes)
-    async ensureRepositoryInitialized() {}
     async beforeInsertOperation(_dto, _user, _queryRunner) {}
     async afterInsertOperation(_entity, _user, _queryRunner) {}
     async beforeUpdateOperation(_dto, _user, _queryRunner) {}
@@ -423,7 +435,6 @@ let ApiService = class ApiService {
             isRaw: false
         };
     }
-    // DTO conversion
     async convertRequestDtoToEntity(dto, user) {
         return Array.isArray(dto) ? await this.convertArrayDtoToEntities(dto, user) : [
             await this.convertSingleDtoToEntity(dto, user)
@@ -458,21 +469,26 @@ let ApiService = class ApiService {
     async getEntityClass() {
         return await this.repository.create();
     }
-    constructor(entityName, repository, cacheManager, utilsService, _loggerName, isCacheable = false, moduleName){
+    constructor(entityName, cacheManager, utilsService, _loggerName, isCacheable = false, moduleName, entity, dataSourceProvider){
         _define_property(this, "entityName", void 0);
-        _define_property(this, "repository", void 0);
         _define_property(this, "cacheManager", void 0);
         _define_property(this, "utilsService", void 0);
         _define_property(this, "_loggerName", void 0);
         _define_property(this, "isCacheable", void 0);
         _define_property(this, "moduleName", void 0);
+        _define_property(this, "repository", void 0);
+        _define_property(this, "repositoryInitialized", void 0);
+        _define_property(this, "_entity", void 0);
+        _define_property(this, "_dataSourceProvider", void 0);
         this.entityName = entityName;
-        this.repository = repository;
         this.cacheManager = cacheManager;
         this.utilsService = utilsService;
         this._loggerName = _loggerName;
         this.isCacheable = isCacheable;
         this.moduleName = moduleName;
+        this.repositoryInitialized = false;
+        this._entity = entity;
+        this._dataSourceProvider = dataSourceProvider;
     }
 };
 _ts_decorate([
@@ -542,3 +558,19 @@ _ts_decorate([
     ]),
     _ts_metadata("design:returntype", Promise)
 ], ApiService.prototype, "delete", null);
+ApiService = _ts_decorate([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        typeof _hybridcacheclass.HybridCache === "undefined" ? Object : _hybridcacheclass.HybridCache,
+        typeof _utilsservice.UtilsService === "undefined" ? Object : _utilsservice.UtilsService,
+        String,
+        Boolean,
+        String,
+        typeof _typeorm.EntityTarget === "undefined" ? Object : _typeorm.EntityTarget,
+        typeof _interfaces.IDataSourceProvider === "undefined" ? Object : _interfaces.IDataSourceProvider
+    ])
+], ApiService);

package/cjs/classes/index.js

@@ -6,7 +6,6 @@ _export_star(require("./api-controller.class"), exports);
 _export_star(require("./api-service.class"), exports);
 _export_star(require("./handle-custome-db-column-type"), exports);
 _export_star(require("./hybrid-cache.class"), exports);
-_export_star(require("./request-scoped-api.service"), exports);
 _export_star(require("./winston.logger.class"), exports);
 _export_star(require("../constants/permissions"), exports);
 function _export_star(from, to) {

package/cjs/dtos/identity-response.dto.js

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "IdentityResponseDto", {
         return IdentityResponseDto;
     }
 });
-const _classtransformer = require("class-transformer");
 const _swagger = require("@nestjs/swagger");
+const _classtransformer = require("class-transformer");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -44,28 +44,28 @@ let IdentityResponseDto = class IdentityResponseDto {
     }
 };
 _ts_decorate([
+    (0, _classtransformer.Expose)(),
     (0, _swagger.ApiProperty)({
         type: String,
         format: 'uuid'
     }),
-    (0, _classtransformer.Expose)(),
     _ts_metadata("design:type", String)
 ], IdentityResponseDto.prototype, "id", void 0);
 _ts_decorate([
+    (0, _classtransformer.Expose)(),
     (0, _swagger.ApiProperty)({
         type: String,
         format: 'date-time'
     }),
-    (0, _classtransformer.Expose)(),
     (0, _classtransformer.Type)(()=>Date),
     _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
 ], IdentityResponseDto.prototype, "createdAt", void 0);
 _ts_decorate([
+    (0, _classtransformer.Expose)(),
     (0, _swagger.ApiProperty)({
         type: String,
         format: 'date-time'
     }),
-    (0, _classtransformer.Expose)(),
     (0, _classtransformer.Type)(()=>Date),
     _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
 ], IdentityResponseDto.prototype, "updatedAt", void 0);
@@ -76,7 +76,6 @@ _ts_decorate([
         nullable: true,
         required: false
     }),
-    (0, _classtransformer.Expose)(),
     (0, _classtransformer.Type)(()=>Date),
     _ts_metadata("design:type", Object)
 ], IdentityResponseDto.prototype, "deletedAt", void 0);
@@ -87,7 +86,6 @@ _ts_decorate([
         nullable: true,
         required: false
     }),
-    (0, _classtransformer.Expose)(),
     _ts_metadata("design:type", Object)
 ], IdentityResponseDto.prototype, "createdById", void 0);
 _ts_decorate([
@@ -97,7 +95,6 @@ _ts_decorate([
         nullable: true,
         required: false
     }),
-    (0, _classtransformer.Expose)(),
     _ts_metadata("design:type", Object)
 ], IdentityResponseDto.prototype, "updatedById", void 0);
 _ts_decorate([
@@ -107,6 +104,5 @@ _ts_decorate([
         nullable: true,
         required: false
     }),
-    (0, _classtransformer.Expose)(),
     _ts_metadata("design:type", Object)
 ], IdentityResponseDto.prototype, "deletedById", void 0);

package/cjs/entities/identity.js

@@ -49,14 +49,16 @@ _ts_decorate([
 _ts_decorate([
     (0, _typeorm.CreateDateColumn)({
         name: 'created_at',
-        type: 'timestamp'
+        type: 'timestamp',
+        select: false
     }),
     _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
 ], Identity.prototype, "createdAt", void 0);
 _ts_decorate([
     (0, _typeorm.UpdateDateColumn)({
         name: 'updated_at',
-        type: 'timestamp'
+        type: 'timestamp',
+        select: false
     }),
     _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
 ], Identity.prototype, "updatedAt", void 0);
@@ -64,6 +66,7 @@ _ts_decorate([
     (0, _typeorm.DeleteDateColumn)({
         name: 'deleted_at',
         type: 'timestamp',
+        select: false,
         nullable: true
     }),
     _ts_metadata("design:type", Object)
@@ -72,6 +75,7 @@ _ts_decorate([
     (0, _typeorm.Column)({
         name: 'created_by_id',
         type: 'uuid',
+        select: false,
         nullable: true
     }),
     _ts_metadata("design:type", Object)
@@ -80,6 +84,7 @@ _ts_decorate([
     (0, _typeorm.Column)({
         name: 'updated_by_id',
         type: 'uuid',
+        select: false,
         nullable: true
     }),
     _ts_metadata("design:type", Object)
@@ -88,6 +93,7 @@ _ts_decorate([
     (0, _typeorm.Column)({
         name: 'deleted_by_id',
         type: 'uuid',
+        select: false,
         nullable: true
     }),
     _ts_metadata("design:type", Object)

package/cjs/modules/datasource/index.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_export_star(require("./datasource.module"), exports);
 _export_star(require("./multi-tenant-datasource.service"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {

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

@@ -43,21 +43,21 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let MultiTenantDataSourceService = class MultiTenantDataSourceService {
+    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);
         });
     }
-    setTenantHeader(header) {
-        this.tenantHeader = header;
-    }
     getDatabaseMode() {
         return this.options?.bootstrapAppConfig?.databaseMode ?? 'single';
     }
@@ -81,91 +81,33 @@ let MultiTenantDataSourceService = class MultiTenantDataSourceService {
         return tenantId ? this.getTenant(tenantId) : null;
     }
     getTenant(tenantId) {
-        return MultiTenantDataSourceService.tenantsRegistry.get(tenantId) ?? null;
-    }
-    getAllTenants() {
-        return Array.from(MultiTenantDataSourceService.tenantsRegistry.values());
-    }
-    getActiveTenants() {
-        return this.getAllTenants();
+        return this.self.tenantsRegistry.get(tenantId) ?? null;
     }
     async getDataSource() {
         return this.isMultiTenant() ? this.getTenantDataSource() : this.getSingleDataSource();
     }
-    async getDataSourceForTenant(tenantId) {
-        const tenant = this.getTenant(tenantId);
-        if (!tenant) {
-            throw new _common.BadRequestException({
-                message: `Tenant '${tenantId}' not found`,
-                messageKey: _constants.SYSTEM_MESSAGES.TENANT_NOT_FOUND,
-                messageVariables: {
-                    tenantId
-                }
-            });
-        }
-        return this.getOrCreateTenantConnection(tenant);
-    }
-    setDataSource(dataSource) {
-        MultiTenantDataSourceService.singleDataSource = dataSource;
-    }
     async getRepository(entity) {
         const dataSource = await this.getDataSource();
         return dataSource.getRepository(entity);
     }
-    async withTenant(tenantId, callback) {
-        const dataSource = await this.getDataSourceForTenant(tenantId);
-        return callback(dataSource);
-    }
-    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  {
-            // Silent failure for individual tenant
-            }
-        }
-        return results;
-    }
-    registerTenant(tenant) {
-        MultiTenantDataSourceService.tenantsRegistry.set(tenant.id, tenant);
-    }
-    async removeTenant(tenantId) {
-        await this.closeTenantConnection(tenantId);
-        MultiTenantDataSourceService.tenantsRegistry.delete(tenantId);
-    }
     async closeTenantConnection(tenantId) {
-        const connection = MultiTenantDataSourceService.tenantConnections.get(tenantId);
+        const connection = this.self.tenantConnections.get(tenantId);
         if (connection?.isInitialized) {
             await connection.destroy();
-            MultiTenantDataSourceService.tenantConnections.delete(tenantId);
+            this.self.tenantConnections.delete(tenantId);
         }
     }
     async onModuleDestroy() {
-        for (const [tenantId] of MultiTenantDataSourceService.tenantConnections){
+        for (const [tenantId] of this.self.tenantConnections){
             await this.closeTenantConnection(tenantId);
         }
     }
-    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) {
@@ -174,20 +116,17 @@ let MultiTenantDataSourceService = class MultiTenantDataSourceService {
                 messageKey: _constants.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 _common.BadRequestException({
@@ -201,19 +140,19 @@ let MultiTenantDataSourceService = class MultiTenantDataSourceService {
         return this.getOrCreateTenantConnection(tenant);
     }
     async getOrCreateTenantConnection(tenant) {
-        const existing = MultiTenantDataSourceService.tenantConnections.get(tenant.id);
+        const existing = this.self.tenantConnections.get(tenant.id);
         if (existing?.isInitialized) return existing;
-        const pendingConnection = MultiTenantDataSourceService.connectionLocks.get(tenant.id);
+        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.self.tenantConnections.set(tenant.id, dataSource);
             return dataSource;
         } finally{
-            MultiTenantDataSourceService.connectionLocks.delete(tenant.id);
+            this.self.connectionLocks.delete(tenant.id);
         }
     }
     getDefaultDatabaseConfig() {