@flusys/nestjs-shared 5.1.1 → 5.1.3

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.1",
+  "version": "5.1.3",
   "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.1"
+    "@flusys/nestjs-core": "5.1.3"
   }
 }

package/cjs/classes/request-scoped-api.service.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "RequestScopedApiService", {
-    enumerable: true,
-    get: function() {
-        return RequestScopedApiService;
-    }
-});
-const _common = require("@nestjs/common");
-const _apiserviceclass = require("./api-service.class");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.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;
-}
-let RequestScopedApiService = class RequestScopedApiService extends _apiserviceclass.ApiService {
-    async ensureRepositoryInitialized() {
-        if (!this.repositoryInitialized) {
-            const entity = this.resolveEntity();
-            const provider = this.getDataSourceProvider();
-            this.repository = await provider.getRepository(entity);
-            this.repositoryInitialized = true;
-        }
-    }
-    /** Initialize additional repositories beyond the primary entity */ async initializeAdditionalRepositories(entities) {
-        const provider = this.getDataSourceProvider();
-        const repositories = [];
-        for (const entity of entities){
-            repositories.push(await provider.getRepository(entity));
-        }
-        return repositories;
-    }
-    /** Get DataSource for direct access (transactions, custom queries) */ async getDataSourceForService() {
-        const provider = this.getDataSourceProvider();
-        return await provider.getDataSource();
-    }
-    constructor(...args){
-        super(...args), _define_property(this, "repositoryInitialized", false);
-    }
-};
-RequestScopedApiService = _ts_decorate([
-    (0, _common.Injectable)({
-        scope: _common.Scope.REQUEST
-    })
-], RequestScopedApiService);

package/cjs/modules/datasource/datasource.module.js

@@ -1,117 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "DataSourceModule", {
-    enumerable: true,
-    get: function() {
-        return DataSourceModule;
-    }
-});
-const _nestjscore = require("@flusys/nestjs-core");
-const _common = require("@nestjs/common");
-const _multitenantdatasourceservice = require("./multi-tenant-datasource.service");
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.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;
-}
-let DataSourceModule = class DataSourceModule {
-    /**
-   * Register with static options
-   */ static forRoot(options) {
-        const { global = false, ...moduleOptions } = options;
-        return {
-            module: DataSourceModule,
-            global,
-            providers: [
-                {
-                    provide: _nestjscore.MODULE_OPTIONS,
-                    useValue: moduleOptions
-                },
-                _multitenantdatasourceservice.MultiTenantDataSourceService
-            ],
-            exports: [
-                _nestjscore.MODULE_OPTIONS,
-                _multitenantdatasourceservice.MultiTenantDataSourceService
-            ]
-        };
-    }
-    /**
-   * Register with async options
-   */ static forRootAsync(asyncOptions) {
-        const { global = false, imports = [] } = asyncOptions;
-        return {
-            module: DataSourceModule,
-            global,
-            imports,
-            providers: [
-                ...this.createAsyncProviders(asyncOptions),
-                _multitenantdatasourceservice.MultiTenantDataSourceService
-            ],
-            exports: [
-                _nestjscore.MODULE_OPTIONS,
-                _multitenantdatasourceservice.MultiTenantDataSourceService
-            ]
-        };
-    }
-    /**
-   * Import for child modules (uses existing MODULE_OPTIONS)
-   */ static forFeature() {
-        return {
-            module: DataSourceModule,
-            providers: [
-                _multitenantdatasourceservice.MultiTenantDataSourceService
-            ],
-            exports: [
-                _multitenantdatasourceservice.MultiTenantDataSourceService
-            ]
-        };
-    }
-    /**
-   * Create async providers based on options
-   */ static createAsyncProviders(options) {
-        if (options.useFactory) {
-            return [
-                {
-                    provide: _nestjscore.MODULE_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject || []
-                }
-            ];
-        }
-        if (options.useClass) {
-            return [
-                {
-                    provide: options.useClass,
-                    useClass: options.useClass
-                },
-                this.createFactoryProvider(options.useClass)
-            ];
-        }
-        if (options.useExisting) {
-            return [
-                this.createFactoryProvider(options.useExisting)
-            ];
-        }
-        return [
-            {
-                provide: _nestjscore.MODULE_OPTIONS,
-                useValue: {}
-            }
-        ];
-    }
-    static createFactoryProvider(factoryClass) {
-        return {
-            provide: _nestjscore.MODULE_OPTIONS,
-            useFactory: async (factory)=>factory.createOptions(),
-            inject: [
-                factoryClass
-            ]
-        };
-    }
-};
-DataSourceModule = _ts_decorate([
-    (0, _common.Module)({})
-], DataSourceModule);

package/classes/request-scoped-api.service.d.ts

@@ -1,14 +0,0 @@
-import { DataSource, EntityTarget, Repository } from 'typeorm';
-import { Identity } from '../entities';
-import { IDataSourceProvider } from '../interfaces';
-import { ApiService } from './api-service.class';
-export declare abstract class RequestScopedApiService<CreateDtoT extends object, UpdateDtoT extends {
-    id: string;
-}, InterfaceT extends Identity, EntityT extends Identity> extends ApiService<CreateDtoT, UpdateDtoT, InterfaceT, EntityT> {
-    private repositoryInitialized;
-    protected abstract resolveEntity(): EntityTarget<EntityT>;
-    protected abstract getDataSourceProvider(): IDataSourceProvider;
-    protected ensureRepositoryInitialized(): Promise<void>;
-    protected initializeAdditionalRepositories(entities: EntityTarget<any>[]): Promise<Repository<any>[]>;
-    protected getDataSourceForService(): Promise<DataSource>;
-}

package/fesm/classes/request-scoped-api.service.js

@@ -1,51 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.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;
-}
-import { Injectable, Scope } from '@nestjs/common';
-import { ApiService } from './api-service.class';
-export class RequestScopedApiService extends ApiService {
-    async ensureRepositoryInitialized() {
-        if (!this.repositoryInitialized) {
-            const entity = this.resolveEntity();
-            const provider = this.getDataSourceProvider();
-            this.repository = await provider.getRepository(entity);
-            this.repositoryInitialized = true;
-        }
-    }
-    /** Initialize additional repositories beyond the primary entity */ async initializeAdditionalRepositories(entities) {
-        const provider = this.getDataSourceProvider();
-        const repositories = [];
-        for (const entity of entities){
-            repositories.push(await provider.getRepository(entity));
-        }
-        return repositories;
-    }
-    /** Get DataSource for direct access (transactions, custom queries) */ async getDataSourceForService() {
-        const provider = this.getDataSourceProvider();
-        return await provider.getDataSource();
-    }
-    constructor(...args){
-        super(...args), _define_property(this, "repositoryInitialized", false);
-    }
-}
-RequestScopedApiService = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    })
-], RequestScopedApiService);