@flusys/nestjs-shared 5.1.2 → 5.2.0

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

@@ -20,12 +20,40 @@ function _ts_decorate(decorators, target, key, desc) {
 function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-import { InternalServerErrorException, NotFoundException } from '@nestjs/common';
-import { In } from 'typeorm';
+import { Injectable, InternalServerErrorException, NotFoundException, Scope } from '@nestjs/common';
+import { EntityTarget, In } from 'typeorm';
 import { ERROR_MESSAGES, SYSTEM_MESSAGES } from '../constants';
 import { LogAction } from '../decorators/log-action.decorator';
 import { DeleteDto } from '../dtos';
-/** Generic API service with CRUD operations and caching support */ export class ApiService {
+import { IDataSourceProvider } from '../interfaces';
+import { UtilsService } from '../modules/utils/utils.service';
+import { HybridCache } from './hybrid-cache.class';
+export 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);
@@ -98,7 +126,7 @@ import { DeleteDto } from '../dtos';
         });
     }
     async findByIds(ids, user, select) {
-        await this.ensureRepositoryInitialized();
+        await this.ensureDataSourceRepository();
         try {
             const query = this.repository.createQueryBuilder(this.entityName);
             query.where({
@@ -126,7 +154,7 @@ import { DeleteDto } from '../dtos';
         }
     }
     async findById(id, user, select) {
-        await this.ensureRepositoryInitialized();
+        await this.ensureDataSourceRepository();
         try {
             const query = this.repository.createQueryBuilder(this.entityName);
             query.where({
@@ -140,18 +168,17 @@ import { DeleteDto } from '../dtos';
                 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 NotFoundException({
+                    const singleOutput = await finalQuery.getOne();
+                    if (!singleOutput) throw new NotFoundException({
                         message: 'No Data Found',
                         messageKey: ERROR_MESSAGES.NOT_FOUND
                     });
-                    result = this.convertEntityToResponseDto(output, false);
+                    result = this.convertEntityToResponseDto(singleOutput, false);
                 }
                 if (this.isCacheable) {
                     await this.cacheManager.set(cacheKey, result);
@@ -167,41 +194,34 @@ import { DeleteDto } from '../dtos';
         }
     }
     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;
@@ -211,7 +231,6 @@ import { DeleteDto } from '../dtos';
                     query.skip(offset).take(limit);
                 }
             }
-            // Generate cache key
             let cacheKey = '';
             if (this.isCacheable) {
                 cacheKey = this.utilsService.getCacheKey(this.entityName, {
@@ -225,7 +244,6 @@ import { DeleteDto } from '../dtos';
                 }
             }
             if (isRaw) {
-                // Handle raw query count manually
                 const rawSubQuery = query.clone().offset(undefined).limit(undefined).distinct(true);
                 const countSql = `
             SELECT COUNT(*) as count
@@ -273,7 +291,7 @@ import { DeleteDto } from '../dtos';
         }
     }
     async delete(option, user) {
-        await this.ensureRepositoryInitialized();
+        await this.ensureDataSourceRepository();
         const queryRunner = this.repository.manager.connection.createQueryRunner();
         await queryRunner.connect();
         await queryRunner.startTransaction();
@@ -305,7 +323,6 @@ import { DeleteDto } from '../dtos';
                 this.clearCacheForAll(),
                 this.clearCacheForId(ids)
             ]);
-            // return null per IService contract
             return null;
         } catch (error) {
             await queryRunner.rollbackTransaction();
@@ -314,7 +331,6 @@ import { DeleteDto } from '../dtos';
             await queryRunner.release();
         }
     }
-    // Caching
     async clearCacheForAll() {
         await this.utilsService.clearCache(this.entityName, this.cacheManager);
     }
@@ -330,13 +346,13 @@ import { DeleteDto } from '../dtos';
             messageKey: 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();
@@ -361,8 +377,6 @@ import { DeleteDto } from '../dtos';
             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) {}
@@ -411,7 +425,6 @@ import { DeleteDto } from '../dtos';
             isRaw: false
         };
     }
-    // DTO conversion
     async convertRequestDtoToEntity(dto, user) {
         return Array.isArray(dto) ? await this.convertArrayDtoToEntities(dto, user) : [
             await this.convertSingleDtoToEntity(dto, user)
@@ -446,21 +459,26 @@ import { DeleteDto } from '../dtos';
     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([
@@ -530,3 +548,19 @@ _ts_decorate([
     ]),
     _ts_metadata("design:returntype", Promise)
 ], ApiService.prototype, "delete", null);
+ApiService = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        typeof HybridCache === "undefined" ? Object : HybridCache,
+        typeof UtilsService === "undefined" ? Object : UtilsService,
+        String,
+        Boolean,
+        String,
+        typeof EntityTarget === "undefined" ? Object : EntityTarget,
+        typeof IDataSourceProvider === "undefined" ? Object : IDataSourceProvider
+    ])
+], ApiService);

package/fesm/classes/index.js

@@ -2,7 +2,6 @@ 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';
 // Re-export permission constants for convenience
 export * from '../constants/permissions';

package/fesm/interfaces/datasource.interface.js

@@ -1,20 +1 @@
-/**
- * Interface for DataSource providers used by RequestScopedApiService.
- * Implement this interface in each module's DataSourceProvider to ensure type safety.
- *
- * @example
- * ```typescript
- * @Injectable()
- * export class IAMDataSourceProvider implements IDataSourceProvider {
- *   constructor(private readonly dataSource: DataSource) {}
- *
- *   async getRepository<T extends ObjectLiteral>(entity: EntityTarget<T>): Promise<Repository<T>> {
- *     return this.dataSource.getRepository(entity);
- *   }
- *
- *   async getDataSource(): Promise<DataSource> {
- *     return this.dataSource;
- *   }
- * }
- * ```
- */ export { };
+export { };

package/fesm/modules/datasource/index.js

@@ -1,2 +1 @@
-export * from './datasource.module';
 export * from './multi-tenant-datasource.service';

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

@@ -33,21 +33,21 @@ import { Request } from 'express';
 import { DataSource } from 'typeorm';
 import { SnakeNamingStrategy } from 'typeorm-naming-strategies';
 export 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';
     }
@@ -71,91 +71,33 @@ export 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 BadRequestException({
-                message: `Tenant '${tenantId}' not found`,
-                messageKey: 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) {
@@ -164,20 +106,17 @@ export class MultiTenantDataSourceService {
                 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 BadRequestException({
@@ -191,19 +130,19 @@ export 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/guards/permission.guard.d.ts

@@ -6,7 +6,7 @@ export declare class PermissionGuard implements CanActivate {
     private readonly reflector;
     private readonly cache?;
     private readonly config;
-    constructor(reflector: Reflector, cache?: HybridCache, config?: PermissionGuardConfig);
+    constructor(reflector: Reflector, cache?: HybridCache | undefined, config?: PermissionGuardConfig);
     canActivate(context: ExecutionContext): Promise<boolean>;
     private normalizeToLogicNode;
     private evaluateLogicNode;

package/interceptors/idempotency.interceptor.d.ts

@@ -5,6 +5,6 @@ export declare class IdempotencyInterceptor implements NestInterceptor {
     private readonly cache?;
     private readonly CACHE_TTL;
     private readonly PROCESSING_MARKER;
-    constructor(cache?: HybridCache);
+    constructor(cache?: HybridCache | undefined);
     intercept<T = any>(context: ExecutionContext, next: CallHandler<T>): Promise<Observable<T>>;
 }

package/interfaces/notification-adapter.interface.d.ts

@@ -1,22 +1,21 @@
 import { NotificationType } from '../enums/notification-type.enum';
-export interface INotificationAdapter {
-    send(options: NotificationSendOptions): Promise<void>;
-    sendToMany(options: NotificationBulkSendOptions): Promise<void>;
-    broadcastToCompany?(companyId: string, title: string, message?: string, type?: NotificationType, data?: Record<string, unknown>): Promise<void>;
-    isUserOnline?(userId: string): boolean;
-}
-interface NotificationBaseOptions {
+export declare const NOTIFICATION_ADAPTER = "NOTIFICATION_ADAPTER";
+export interface INotificationContent {
     title: string;
-    message?: string;
+    message?: string | null;
     type?: NotificationType;
-    data?: Record<string, unknown>;
-    companyId?: string;
+    data?: Record<string, unknown> | null;
+    companyId?: string | null;
+    realtime?: boolean;
 }
-export interface NotificationSendOptions extends NotificationBaseOptions {
+export interface INotificationSendOptions extends INotificationContent {
     userId: string;
 }
-export interface NotificationBulkSendOptions extends NotificationBaseOptions {
+export interface INotificationBulkSendOptions extends INotificationContent {
     userIds: string[];
 }
-export declare const NOTIFICATION_ADAPTER = "NOTIFICATION_ADAPTER";
-export {};
+export interface INotificationAdapter {
+    send(options: INotificationSendOptions): Promise<void>;
+    sendToMany(options: INotificationBulkSendOptions): Promise<void>;
+    isUserOnline?(userId: string): boolean;
+}

package/modules/datasource/index.d.ts

@@ -1,2 +1 @@
-export * from './datasource.module';
 export * from './multi-tenant-datasource.service';

package/modules/datasource/multi-tenant-datasource.service.d.ts

@@ -3,8 +3,8 @@ import { OnModuleDestroy } from '@nestjs/common';
 import { Request } from 'express';
 import { DataSource, EntityTarget, ObjectLiteral, Repository } from 'typeorm';
 export declare class MultiTenantDataSourceService implements OnModuleDestroy {
-    protected readonly options?: IDataSourceServiceOptions;
-    protected readonly request?: Request;
+    protected readonly options?: IDataSourceServiceOptions | undefined;
+    protected readonly request?: Request | undefined;
     protected static readonly tenantConnections: Map<string, DataSource>;
     protected static singleDataSource: DataSource | null;
     protected static readonly tenantsRegistry: Map<string, ITenantDatabaseConfig>;
@@ -12,28 +12,19 @@ export declare class MultiTenantDataSourceService implements OnModuleDestroy {
     protected static readonly connectionLocks: Map<string, Promise<DataSource>>;
     protected static singleConnectionLock: Promise<DataSource> | null;
     protected tenantHeader: string;
-    constructor(options?: IDataSourceServiceOptions, request?: Request);
+    constructor(options?: IDataSourceServiceOptions | undefined, request?: Request | undefined);
+    private get self();
     private initializeFromOptions;
     private registerTenants;
-    setTenantHeader(header: string): void;
     getDatabaseMode(): DatabaseMode;
     isMultiTenant(): boolean;
     getCurrentTenantId(): string | null;
     getCurrentTenant(): ITenantDatabaseConfig | null;
     getTenant(tenantId: string): ITenantDatabaseConfig | null;
-    getAllTenants(): ITenantDatabaseConfig[];
-    getActiveTenants(): ITenantDatabaseConfig[];
     getDataSource(): Promise<DataSource>;
-    getDataSourceForTenant(tenantId: string): Promise<DataSource>;
-    setDataSource(dataSource: DataSource): void;
     getRepository<T extends ObjectLiteral>(entity: EntityTarget<T>): Promise<Repository<T>>;
-    withTenant<T>(tenantId: string, callback: (ds: DataSource) => Promise<T>): Promise<T>;
-    forAllTenants<T>(callback: (tenant: ITenantDatabaseConfig, ds: DataSource) => Promise<T>): Promise<Map<string, T>>;
-    registerTenant(tenant: ITenantDatabaseConfig): void;
-    removeTenant(tenantId: string): Promise<void>;
     closeTenantConnection(tenantId: string): Promise<void>;
     onModuleDestroy(): Promise<void>;
-    static reset(): void;
     protected getSingleDataSource(): Promise<DataSource>;
     protected getTenantDataSource(): Promise<DataSource>;
     protected getOrCreateTenantConnection(tenant: ITenantDatabaseConfig): Promise<DataSource>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-shared",
-  "version": "5.1.2",
+  "version": "5.2.0",
   "description": "Common shared utilities for Flusys NestJS applications",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -93,25 +93,25 @@
     }
   },
   "peerDependencies": {
-    "@keyv/redis": "^5.0.1",
-    "@nestjs/common": "^10.0.0 || ^11.0.0",
-    "@nestjs/config": "^3.0.0 || ^4.0.0",
-    "@nestjs/core": "^10.0.0 || ^11.0.0",
-    "@nestjs/jwt": "^10.0.0 || ^11.0.0",
-    "@nestjs/passport": "^10.0.0 || ^11.0.0",
-    "@nestjs/swagger": "^7.0.0 || ^11.0.0",
-    "@nestjs/typeorm": "^10.0.0 || ^11.0.0",
-    "cacheable": "^2.0.0",
-    "class-transformer": "^0.5.0",
-    "class-validator": "^0.14.0",
-    "keyv": "^5.0.1",
+    "@keyv/redis": "^5.1.0",
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/config": "^4.0.0",
+    "@nestjs/core": "^11.0.0",
+    "@nestjs/jwt": "^11.0.0",
+    "@nestjs/passport": "^11.0.0",
+    "@nestjs/swagger": "^11.0.0",
+    "@nestjs/typeorm": "^11.0.0",
+    "cacheable": "^2.1.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.0 || ^0.15.0",
+    "keyv": "^5.0.0",
     "typeorm": "^0.3.0",
     "winston": "^3.0.0",
     "winston-daily-rotate-file": "^5.0.0",
-    "express": "^4.18.0",
+    "express": "^4.18.0 || ^5.0.0",
     "rxjs": "^7.8.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "5.1.2"
+    "@flusys/nestjs-core": "5.2.0"
   }
 }