@flusys/nestjs-notification 3.0.1

package/cjs/services/notification-datasource.provider.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NotificationDataSourceProvider", {
+    enumerable: true,
+    get: function() {
+        return NotificationDataSourceProvider;
+    }
+});
+const _modules = require("@flusys/nestjs-shared/modules");
+const _common = require("@nestjs/common");
+const _core = require("@nestjs/core");
+const _express = require("express");
+const _notificationconfigservice = require("./notification-config.service");
+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 _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+let NotificationDataSourceProvider = class NotificationDataSourceProvider extends _modules.MultiTenantDataSourceService {
+    static buildParentOptions(options) {
+        return {
+            bootstrapAppConfig: options.bootstrapAppConfig,
+            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
+            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
+            tenants: options.config?.tenants
+        };
+    }
+    getEnableCompanyFeatureForTenant(tenant) {
+        return tenant?.enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
+    }
+    async getNotificationEntities(enableCompanyFeature) {
+        const enable = enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
+        const entities = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")));
+        return enable ? [
+            entities.NotificationWithCompany
+        ] : [
+            entities.Notification
+        ];
+    }
+    async createDataSourceFromConfig(config) {
+        const currentTenant = this.getCurrentTenant();
+        const enableCompanyFeature = this.getEnableCompanyFeatureForTenant(currentTenant ?? undefined);
+        const entities = await this.getNotificationEntities(enableCompanyFeature);
+        return super.createDataSourceFromConfig(config, entities);
+    }
+    async getSingleDataSource() {
+        if (NotificationDataSourceProvider.singleDataSource?.isInitialized) {
+            return NotificationDataSourceProvider.singleDataSource;
+        }
+        if (NotificationDataSourceProvider.singleConnectionLock) {
+            return NotificationDataSourceProvider.singleConnectionLock;
+        }
+        const config = this.getDefaultDatabaseConfig();
+        if (!config) {
+            throw new _common.InternalServerErrorException('No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.');
+        }
+        const connectionPromise = this.createDataSourceFromConfig(config);
+        NotificationDataSourceProvider.singleConnectionLock = connectionPromise;
+        try {
+            const dataSource = await connectionPromise;
+            NotificationDataSourceProvider.singleDataSource = dataSource;
+            return dataSource;
+        } finally{
+            NotificationDataSourceProvider.singleConnectionLock = null;
+        }
+    }
+    async getOrCreateTenantConnection(tenant) {
+        const existing = NotificationDataSourceProvider.tenantConnections.get(tenant.id);
+        if (existing?.isInitialized) {
+            return existing;
+        }
+        const pendingConnection = NotificationDataSourceProvider.connectionLocks.get(tenant.id);
+        if (pendingConnection) {
+            return pendingConnection;
+        }
+        const config = this.buildTenantDatabaseConfig(tenant);
+        const connectionPromise = this.createDataSourceFromConfig(config);
+        NotificationDataSourceProvider.connectionLocks.set(tenant.id, connectionPromise);
+        try {
+            const dataSource = await connectionPromise;
+            NotificationDataSourceProvider.tenantConnections.set(tenant.id, dataSource);
+            return dataSource;
+        } finally{
+            NotificationDataSourceProvider.connectionLocks.delete(tenant.id);
+        }
+    }
+    constructor(configService, request){
+        super(NotificationDataSourceProvider.buildParentOptions(configService.getOptions()), request), _define_property(this, "configService", void 0), _define_property(this, "logger", void 0), this.configService = configService, this.logger = new _common.Logger(NotificationDataSourceProvider.name);
+    }
+};
+_define_property(NotificationDataSourceProvider, "tenantConnections", new Map());
+_define_property(NotificationDataSourceProvider, "singleDataSource", null);
+_define_property(NotificationDataSourceProvider, "tenantsRegistry", new Map());
+_define_property(NotificationDataSourceProvider, "initialized", false);
+_define_property(NotificationDataSourceProvider, "connectionLocks", new Map());
+_define_property(NotificationDataSourceProvider, "singleConnectionLock", null);
+NotificationDataSourceProvider = _ts_decorate([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)(_notificationconfigservice.NotificationConfigService)),
+    _ts_param(1, (0, _common.Optional)()),
+    _ts_param(1, (0, _common.Inject)(_core.REQUEST)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _notificationconfigservice.NotificationConfigService === "undefined" ? Object : _notificationconfigservice.NotificationConfigService,
+        typeof _express.Request === "undefined" ? Object : _express.Request
+    ])
+], NotificationDataSourceProvider);

package/cjs/services/notification-helper.service.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NotificationHelperService", {
+    enumerable: true,
+    get: function() {
+        return NotificationHelperService;
+    }
+});
+const _common = require("@nestjs/common");
+const _classes = require("@flusys/nestjs-shared/classes");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _notificationconfigservice = require("./notification-config.service");
+const _notificationdatasourceprovider = require("./notification-datasource.provider");
+const _gateways = require("../gateways");
+const _entities = require("../entities");
+const _enums = require("@flusys/nestjs-shared/enums");
+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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+let NotificationHelperService = class NotificationHelperService {
+    async getDataSource() {
+        if (!this.dataSource) {
+            this.dataSource = await this.dataSourceProvider.getDataSource();
+        }
+        return this.dataSource;
+    }
+    async getRepository() {
+        const ds = await this.getDataSource();
+        const EntityClass = this.configService.isCompanyFeatureEnabled() ? _entities.NotificationWithCompany : _entities.Notification;
+        return ds.getRepository(EntityClass);
+    }
+    async send(options) {
+        const { userId, title, message = null, type = _enums.NotificationType.INFO, data = null, companyId } = options;
+        const repo = await this.getRepository();
+        const entity = {
+            userId,
+            type,
+            title,
+            message,
+            data,
+            isRead: false
+        };
+        if (this.configService.isCompanyFeatureEnabled() && companyId) {
+            entity.companyId = companyId;
+        }
+        const saved = await repo.save(entity);
+        await this.clearCache();
+        this.emitRealtime(saved);
+        this.logger.debug(`Notification sent to user ${userId}: ${title}`);
+        return saved;
+    }
+    async sendToMany(options) {
+        const { userIds, title, message = null, type = _enums.NotificationType.INFO, data = null, companyId } = options;
+        const repo = await this.getRepository();
+        const entities = userIds.map((userId)=>({
+                userId,
+                type,
+                title,
+                message,
+                data,
+                isRead: false,
+                ...this.configService.isCompanyFeatureEnabled() && companyId ? {
+                    companyId
+                } : {}
+            }));
+        const saved = await repo.save(entities);
+        await this.clearCache();
+        for (const notification of saved){
+            this.emitRealtime(notification);
+        }
+        this.logger.debug(`Notification sent to ${userIds.length} users: ${title}`);
+        return saved;
+    }
+    async sendToCompany(companyId, title, message, type = _enums.NotificationType.INFO, data) {
+        if (!this.configService.isCompanyFeatureEnabled()) {
+            this.logger.warn('sendToCompany called but company feature is disabled');
+            return;
+        }
+        if (this.configService.isRealtimeEnabled() && this.gateway) {
+            const payload = {
+                id: `broadcast-${Date.now()}`,
+                type,
+                title,
+                message: message ?? null,
+                data: data ?? null,
+                createdAt: new Date()
+            };
+            this.gateway.emitToCompany(companyId, 'notification:new', payload);
+            this.logger.debug(`Broadcast notification sent to company ${companyId}: ${title}`);
+        }
+    }
+    isUserOnline(userId) {
+        return this.gateway?.isUserOnline(userId) ?? false;
+    }
+    getOnlineUserCount() {
+        return this.gateway?.getOnlineUserCount() ?? 0;
+    }
+    emitRealtime(notification) {
+        if (!this.configService.isRealtimeEnabled() || !this.gateway) {
+            return;
+        }
+        const ext = notification;
+        const payload = this.toPayload(notification);
+        if (this.configService.isCompanyFeatureEnabled() && ext.companyId) {
+            // Company feature enabled - emit only to sockets in matching company context
+            this.gateway.emitToUserInCompany(notification.userId, ext.companyId, 'notification:new', payload);
+        } else {
+            // No company feature or no companyId - emit to all user's sockets
+            this.gateway.emitToUser(notification.userId, 'notification:new', payload);
+        }
+    }
+    toPayload(notification) {
+        return {
+            id: notification.id,
+            type: notification.type,
+            title: notification.title,
+            message: notification.message,
+            data: notification.data,
+            createdAt: notification.createdAt
+        };
+    }
+    async clearCache() {
+        await this.utilsService.clearCache(this.entityName, this.cacheManager);
+    }
+    constructor(cacheManager, utilsService, configService, dataSourceProvider, gateway){
+        _define_property(this, "cacheManager", void 0);
+        _define_property(this, "utilsService", void 0);
+        _define_property(this, "configService", void 0);
+        _define_property(this, "dataSourceProvider", void 0);
+        _define_property(this, "gateway", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "entityName", void 0);
+        _define_property(this, "dataSource", void 0);
+        this.cacheManager = cacheManager;
+        this.utilsService = utilsService;
+        this.configService = configService;
+        this.dataSourceProvider = dataSourceProvider;
+        this.gateway = gateway;
+        this.logger = new _common.Logger(NotificationHelperService.name);
+        this.entityName = 'notification';
+        this.dataSource = null;
+    }
+};
+NotificationHelperService = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_param(0, (0, _common.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0, _common.Inject)(_modules.UtilsService)),
+    _ts_param(2, (0, _common.Inject)(_notificationconfigservice.NotificationConfigService)),
+    _ts_param(3, (0, _common.Inject)(_notificationdatasourceprovider.NotificationDataSourceProvider)),
+    _ts_param(4, (0, _common.Optional)()),
+    _ts_param(4, (0, _common.Inject)(_gateways.NotificationGateway)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache,
+        typeof _modules.UtilsService === "undefined" ? Object : _modules.UtilsService,
+        typeof _notificationconfigservice.NotificationConfigService === "undefined" ? Object : _notificationconfigservice.NotificationConfigService,
+        typeof _notificationdatasourceprovider.NotificationDataSourceProvider === "undefined" ? Object : _notificationdatasourceprovider.NotificationDataSourceProvider,
+        typeof _gateways.NotificationGateway === "undefined" ? Object : _gateways.NotificationGateway
+    ])
+], NotificationHelperService);

package/cjs/services/notification.service.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NotificationService", {
+    enumerable: true,
+    get: function() {
+        return NotificationService;
+    }
+});
+const _classes = require("@flusys/nestjs-shared/classes");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _utils = require("@flusys/nestjs-shared/utils");
+const _common = require("@nestjs/common");
+const _entities = require("../entities");
+const _gateways = require("../gateways");
+const _notificationconfigservice = require("./notification-config.service");
+const _notificationdatasourceprovider = require("./notification-datasource.provider");
+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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+let NotificationService = class NotificationService extends _classes.RequestScopedApiService {
+    resolveEntity() {
+        return this.notificationConfig.isCompanyFeatureEnabled() ? _entities.NotificationWithCompany : _entities.Notification;
+    }
+    getDataSourceProvider() {
+        return this.dataSourceProvider;
+    }
+    async convertSingleDtoToEntity(dto, user) {
+        let entity = {};
+        if ('id' in dto && dto.id) {
+            const existing = await this.repository.findOne({
+                where: {
+                    id: dto.id
+                }
+            });
+            if (!existing) throw new _common.NotFoundException('Notification not found');
+            entity = existing;
+        }
+        const merged = {
+            ...entity,
+            userId: user?.id ?? entity.userId,
+            type: dto.type ?? entity.type ?? 'info',
+            title: dto.title ?? entity.title,
+            message: dto.message ?? entity.message,
+            data: dto.data ?? entity.data,
+            isRead: entity.isRead ?? false,
+            readAt: entity.readAt
+        };
+        if (this.notificationConfig.isCompanyFeatureEnabled()) {
+            merged.companyId = dto.companyId ?? user?.companyId ?? entity.companyId ?? null;
+        }
+        return merged;
+    }
+    async getFilterQuery(query, filter, _user) {
+        for (const [key, value] of Object.entries(filter)){
+            if (key === 'isRead' && typeof value === 'boolean') {
+                query.andWhere(`${this.entityName}.isRead = :isRead`, {
+                    isRead: value
+                });
+            } else if (key === 'type' && value) {
+                query.andWhere(`${this.entityName}.type = :type`, {
+                    type: value
+                });
+            } else if (key === 'userId' && value) {
+                query.andWhere(`${this.entityName}.userId = :userId`, {
+                    userId: value
+                });
+            }
+        }
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getExtraManipulateQuery(query, filterDto, user) {
+        const result = await super.getExtraManipulateQuery(query, filterDto, user);
+        if (user?.id) {
+            query.andWhere(`${this.entityName}.userId = :currentUserId`, {
+                currentUserId: user.id
+            });
+        }
+        (0, _utils.applyCompanyFilter)(query, {
+            isCompanyFeatureEnabled: this.notificationConfig.isCompanyFeatureEnabled(),
+            entityAlias: this.entityName
+        }, user);
+        if (!filterDto?.sort || Object.keys(filterDto.sort).length === 0) {
+            query.orderBy(`${this.entityName}.createdAt`, 'DESC');
+        }
+        return result;
+    }
+    async afterInsertOperation(entities, _user, _qr) {
+        for (const entity of entities){
+            const ext = entity;
+            this.emitToUserInCompanyIfRealtime(entity.userId, ext.companyId, 'notification:new', this.toPayload(entity));
+        }
+    }
+    async markAsRead(id, user) {
+        await this.ensureRepositoryInitialized();
+        const notification = await this.repository.findOne({
+            where: {
+                id,
+                userId: user.id
+            }
+        });
+        if (!notification) {
+            throw new _common.NotFoundException('Notification not found');
+        }
+        notification.isRead = true;
+        notification.readAt = new Date();
+        await this.repository.save(notification);
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId([
+                notification
+            ])
+        ]);
+        // Emit to user's sockets in the same company context
+        const ext = notification;
+        this.emitToUserInCompanyIfRealtime(user.id, ext.companyId ?? user.companyId, 'notification:read', {
+            id
+        });
+        return notification;
+    }
+    async markAllAsRead(user) {
+        await this.ensureRepositoryInitialized();
+        const result = await this.repository.update({
+            userId: user.id,
+            isRead: false
+        }, {
+            isRead: true,
+            readAt: new Date()
+        });
+        await this.clearCacheForAll();
+        // Emit to user's sockets in the current company context
+        this.emitToUserInCompanyIfRealtime(user.id, user.companyId, 'notification:read-all', {});
+        return result.affected ?? 0;
+    }
+    async getUnreadCount(user) {
+        await this.ensureRepositoryInitialized();
+        return this.repository.count({
+            where: {
+                userId: user.id,
+                isRead: false
+            }
+        });
+    }
+    toPayload(entity) {
+        return {
+            id: entity.id,
+            type: entity.type,
+            title: entity.title,
+            message: entity.message,
+            data: entity.data,
+            createdAt: entity.createdAt
+        };
+    }
+    /**
+   * Emit to user's sockets within a specific company context.
+   * If company feature is enabled and companyId is provided, only sockets
+   * connected with that company will receive the event.
+   */ emitToUserInCompanyIfRealtime(userId, companyId, event, payload) {
+        if (!this.notificationConfig.isRealtimeEnabled() || !this.gateway) {
+            return;
+        }
+        if (this.notificationConfig.isCompanyFeatureEnabled() && companyId) {
+            // Company feature enabled - emit only to sockets in matching company context
+            this.gateway.emitToUserInCompany(userId, companyId, event, payload);
+        } else {
+            // No company feature or no companyId - emit to all user's sockets
+            this.gateway.emitToUser(userId, event, payload);
+        }
+    }
+    constructor(cacheManager, utilsService, notificationConfig, dataSourceProvider, gateway){
+        super('notification', null, cacheManager, utilsService, NotificationService.name, false), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "notificationConfig", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "gateway", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.notificationConfig = notificationConfig, this.dataSourceProvider = dataSourceProvider, this.gateway = gateway;
+    }
+};
+NotificationService = _ts_decorate([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0, _common.Inject)(_modules.UtilsService)),
+    _ts_param(2, (0, _common.Inject)(_notificationconfigservice.NotificationConfigService)),
+    _ts_param(3, (0, _common.Inject)(_notificationdatasourceprovider.NotificationDataSourceProvider)),
+    _ts_param(4, (0, _common.Optional)()),
+    _ts_param(4, (0, _common.Inject)(_gateways.NotificationGateway)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache,
+        typeof _modules.UtilsService === "undefined" ? Object : _modules.UtilsService,
+        typeof _notificationconfigservice.NotificationConfigService === "undefined" ? Object : _notificationconfigservice.NotificationConfigService,
+        typeof _notificationdatasourceprovider.NotificationDataSourceProvider === "undefined" ? Object : _notificationdatasourceprovider.NotificationDataSourceProvider,
+        typeof _gateways.NotificationGateway === "undefined" ? Object : _gateways.NotificationGateway
+    ])
+], NotificationService);

package/config/index.d.ts

@@ -0,0 +1 @@
+export * from './notification.constants';

package/config/notification.constants.d.ts

@@ -0,0 +1 @@
+export declare const NOTIFICATION_MODULE_OPTIONS = "NOTIFICATION_MODULE_OPTIONS";

package/controllers/index.d.ts

@@ -0,0 +1 @@
+export * from './notification.controller';

package/controllers/notification.controller.d.ts

@@ -0,0 +1,26 @@
+import { BulkResponseDto, MessageResponseDto, SingleResponseDto } from '@flusys/nestjs-shared/dtos';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { CreateNotificationDto, MarkReadDto, NotificationResponseDto, SendBulkNotificationDto, SendNotificationDto, UnreadCountResponseDto, UpdateNotificationDto } from '../dtos';
+import { NotificationHelperService } from '../services/notification-helper.service';
+import { NotificationService } from '../services/notification.service';
+declare const NotificationController_base: abstract new (service: NotificationService) => {
+    service: NotificationService;
+    insert(addDto: CreateNotificationDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<NotificationResponseDto>>;
+    insertMany(addDto: CreateNotificationDto[], user: ILoggedUserInfo | null): Promise<BulkResponseDto<NotificationResponseDto>>;
+    getById(id: string, body: import("@flusys/nestjs-shared/dtos").GetByIdBodyDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<NotificationResponseDto>>;
+    update(updateDto: UpdateNotificationDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<NotificationResponseDto>>;
+    updateMany(updateDtos: UpdateNotificationDto[], user: ILoggedUserInfo | null): Promise<BulkResponseDto<NotificationResponseDto>>;
+    getAll(filterAndPaginationDto: import("@flusys/nestjs-shared/dtos").FilterAndPaginationDto, user: ILoggedUserInfo | null, search?: string): Promise<import("@flusys/nestjs-shared/dtos").ListResponseDto<NotificationResponseDto>>;
+    delete(deleteDto: import("@flusys/nestjs-shared/dtos").DeleteDto, user: ILoggedUserInfo | null): Promise<MessageResponseDto>;
+};
+export declare class NotificationController extends NotificationController_base {
+    service: NotificationService;
+    private readonly notificationHelper;
+    constructor(service: NotificationService, notificationHelper: NotificationHelperService);
+    markAsRead(dto: MarkReadDto, user: ILoggedUserInfo): Promise<SingleResponseDto<NotificationResponseDto>>;
+    markAllAsRead(user: ILoggedUserInfo): Promise<MessageResponseDto>;
+    getUnreadCount(user: ILoggedUserInfo): Promise<SingleResponseDto<UnreadCountResponseDto>>;
+    sendNotification(dto: SendNotificationDto): Promise<SingleResponseDto<NotificationResponseDto>>;
+    sendBulkNotification(dto: SendBulkNotificationDto): Promise<BulkResponseDto<NotificationResponseDto>>;
+}
+export {};

package/docs/index.d.ts

@@ -0,0 +1 @@
+export * from './notification-swagger.config';

package/docs/notification-swagger.config.d.ts

@@ -0,0 +1,2 @@
+import { IModuleSwaggerOptions } from '@flusys/nestjs-core/docs';
+export declare function notificationSwaggerConfig(): IModuleSwaggerOptions;

package/dtos/index.d.ts

@@ -0,0 +1 @@
+export * from './notification.dto';

package/dtos/notification.dto.d.ts

@@ -0,0 +1,47 @@
+import { NotificationType } from '@flusys/nestjs-shared/enums';
+declare class NotificationContentDto {
+    title: string;
+    message?: string;
+    type?: NotificationType;
+    data?: Record<string, unknown>;
+    companyId?: string;
+}
+declare class UserIdDto {
+    userId: string;
+}
+declare class UserIdsDto {
+    userIds: string[];
+}
+declare const CreateNotificationDto_base: import("@nestjs/common").Type<NotificationContentDto & UserIdDto>;
+export declare class CreateNotificationDto extends CreateNotificationDto_base {
+}
+declare const UpdateNotificationDto_base: import("@nestjs/common").Type<Partial<Omit<CreateNotificationDto, "userId">>>;
+export declare class UpdateNotificationDto extends UpdateNotificationDto_base {
+    id: string;
+}
+export declare class MarkReadDto {
+    id: string;
+}
+export declare class NotificationResponseDto {
+    id: string;
+    userId: string;
+    type: string;
+    title: string;
+    message?: string | null;
+    data?: Record<string, unknown> | null;
+    isRead: boolean;
+    readAt?: Date | null;
+    companyId?: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare class UnreadCountResponseDto {
+    count: number;
+}
+declare const SendNotificationDto_base: import("@nestjs/common").Type<NotificationContentDto & UserIdDto>;
+export declare class SendNotificationDto extends SendNotificationDto_base {
+}
+declare const SendBulkNotificationDto_base: import("@nestjs/common").Type<NotificationContentDto & UserIdsDto>;
+export declare class SendBulkNotificationDto extends SendBulkNotificationDto_base {
+}
+export {};