@flusys/nestjs-shared 5.1.2 → 5.1.3

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,41 +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 — always call so subclasses can define a default column set
             const { query: selectQuery, isRaw: selectIsRaw } = await this.getSelectQuery(query, user, filterAndPaginationDto.select);
             query = selectQuery;
             isRaw = isRaw || selectIsRaw;
-            // Apply sort
             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;
@@ -221,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, {
@@ -235,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
@@ -283,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();
@@ -315,7 +333,6 @@ let ApiService = class ApiService {
                 this.clearCacheForAll(),
                 this.clearCacheForId(ids)
             ]);
-            // return null per IService contract
             return null;
         } catch (error) {
             await queryRunner.rollbackTransaction();
@@ -324,7 +341,6 @@ let ApiService = class ApiService {
             await queryRunner.release();
         }
     }
-    // Caching
     async clearCacheForAll() {
         await this.utilsService.clearCache(this.entityName, this.cacheManager);
     }
@@ -340,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();
@@ -371,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) {}
@@ -421,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)
@@ -456,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([
@@ -540,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/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() {

package/classes/api-service.class.d.ts

@@ -1,20 +1,28 @@
-import { QueryRunner, Repository, SelectQueryBuilder } from 'typeorm';
+import { DataSource, EntityTarget, QueryRunner, Repository, SelectQueryBuilder } from 'typeorm';
 import { DeleteDto, FilterAndPaginationDto } from '../dtos';
 import { Identity, RawEntity } from '../entities';
-import { ILoggedUserInfo, IService } from '../interfaces';
+import { IDataSourceProvider, ILoggedUserInfo, IService } from '../interfaces';
 import { UtilsService } from '../modules/utils/utils.service';
 import { HybridCache } from './hybrid-cache.class';
 export declare abstract class ApiService<CreateDtoT extends object, UpdateDtoT extends {
     id: string;
 }, InterfaceT extends Identity, EntityT extends Identity> implements IService<CreateDtoT, UpdateDtoT, InterfaceT> {
     protected entityName: string;
-    protected repository: Repository<EntityT>;
     protected cacheManager: HybridCache;
     protected utilsService: UtilsService;
     protected _loggerName: string;
     protected isCacheable: boolean;
-    protected moduleName?: string;
-    constructor(entityName: string, repository: Repository<EntityT>, cacheManager: HybridCache, utilsService: UtilsService, _loggerName: string, isCacheable?: boolean, moduleName?: string);
+    protected moduleName?: string | undefined;
+    protected repository: Repository<EntityT>;
+    private repositoryInitialized;
+    private _entity?;
+    private _dataSourceProvider?;
+    constructor(entityName: string, cacheManager: HybridCache, utilsService: UtilsService, _loggerName: string, isCacheable?: boolean, moduleName?: string | undefined, entity?: EntityTarget<EntityT>, dataSourceProvider?: IDataSourceProvider);
+    protected resolveEntity(): EntityTarget<EntityT>;
+    protected getDataSourceProvider(): IDataSourceProvider;
+    protected ensureDataSourceRepository(): Promise<void>;
+    protected resolveRepositories(entities: EntityTarget<any>[]): Promise<Repository<any>[]>;
+    protected getDataSourceForService(): Promise<DataSource>;
     insert(dto: CreateDtoT, user: ILoggedUserInfo | null): Promise<InterfaceT>;
     insertMany(dtos: Array<CreateDtoT>, user: ILoggedUserInfo | null): Promise<InterfaceT[]>;
     update(dto: UpdateDtoT, user: ILoggedUserInfo | null): Promise<InterfaceT>;
@@ -32,7 +40,6 @@ export declare abstract class ApiService<CreateDtoT extends object, UpdateDtoT e
     private handleError;
     private ensureArray;
     private executeInTransaction;
-    protected ensureRepositoryInitialized(): Promise<void>;
     protected beforeInsertOperation(_dto: CreateDtoT | Array<CreateDtoT>, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
     protected afterInsertOperation(_entity: EntityT[], _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
     protected beforeUpdateOperation(_dto: UpdateDtoT | Array<UpdateDtoT>, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;

package/classes/index.d.ts

@@ -2,6 +2,5 @@ export * from './api-controller.class';
 export * from './api-service.class';
 export * from './handle-custome-db-column-type';
 export * from './hybrid-cache.class';
-export * from './request-scoped-api.service';
 export * from './winston.logger.class';
 export * from '../constants/permissions';

package/decorators/current-user.decorator.d.ts

@@ -1 +1 @@
-export declare const CurrentUser: (...dataOrPipes: (string | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+export declare const CurrentUser: (...dataOrPipes: (string | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>> | undefined)[]) => ParameterDecorator;