@flusys/nestjs-notification 5.1.1 → 5.1.3

package/controllers/notification.controller.d.ts

@@ -4,19 +4,19 @@ import { CreateNotificationDto, MarkReadDto, NotificationResponseDto, SendBulkNo
 import { NotificationHelperService } from '../services/notification-helper.service';
 import { NotificationService } from '../services/notification.service';
 declare const NotificationController_base: abstract new (service: NotificationService) => {
-    readonly enabledEndpoints: import("@flusys/nestjs-shared/classes").ApiEndpoint[] | "all";
+    readonly enabledEndpoints: import("@flusys/nestjs-shared").ApiEndpoint[] | "all";
     service: NotificationService;
-    isEnabled(endpoint: import("@flusys/nestjs-shared/classes").ApiEndpoint): boolean;
+    isEnabled(endpoint: import("@flusys/nestjs-shared").ApiEndpoint): boolean;
     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>>;
-    getByIds(body: import("@flusys/nestjs-shared/dtos").GetByIdsDto, user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").ListResponseDto<NotificationResponseDto>>;
+    getById(id: string, body: import("@flusys/nestjs-shared").GetByIdBodyDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<NotificationResponseDto>>;
+    getByIds(body: import("@flusys/nestjs-shared").GetByIdsDto, user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").ListResponseDto<NotificationResponseDto>>;
     update(updateDto: UpdateNotificationDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<NotificationResponseDto>>;
     updateMany(updateDtos: UpdateNotificationDto[], user: ILoggedUserInfo | null): Promise<BulkResponseDto<NotificationResponseDto>>;
     bulkUpsert(dtos: (CreateNotificationDto | UpdateNotificationDto)[], user: ILoggedUserInfo | null): Promise<BulkResponseDto<NotificationResponseDto>>;
     getByFilter(filter: Record<string, any>, user: ILoggedUserInfo | null): Promise<SingleResponseDto<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>;
+    getAll(filterAndPaginationDto: import("@flusys/nestjs-shared").FilterAndPaginationDto, user: ILoggedUserInfo | null, search?: string): Promise<import("@flusys/nestjs-shared").ListResponseDto<NotificationResponseDto>>;
+    delete(deleteDto: import("@flusys/nestjs-shared").DeleteDto, user: ILoggedUserInfo | null): Promise<MessageResponseDto>;
 };
 export declare class NotificationController extends NotificationController_base {
     service: NotificationService;

package/dtos/notification.dto.d.ts

@@ -25,7 +25,7 @@ export declare class MarkReadDto {
 export declare class NotificationResponseDto {
     id: string;
     userId: string;
-    type: string;
+    type: NotificationType;
     title: string;
     message?: string | null;
     data?: Record<string, unknown> | null;

package/fesm/adapters/notification.adapter.js

@@ -25,31 +25,14 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { Injectable, Inject } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { NotificationHelperService } from '../services/notification-helper.service';
 export class NotificationAdapter {
     async send(options) {
-        await this.notificationHelper.send({
-            userId: options.userId,
-            title: options.title,
-            message: options.message,
-            type: options.type,
-            data: options.data,
-            companyId: options.companyId
-        });
+        await this.notificationHelper.send(options);
     }
     async sendToMany(options) {
-        await this.notificationHelper.sendToMany({
-            userIds: options.userIds,
-            title: options.title,
-            message: options.message,
-            type: options.type,
-            data: options.data,
-            companyId: options.companyId
-        });
-    }
-    async broadcastToCompany(companyId, title, message, type, data) {
-        await this.notificationHelper.sendToCompany(companyId, title, message, type, data);
+        await this.notificationHelper.sendToMany(options);
     }
     isUserOnline(userId) {
         return this.notificationHelper.isUserOnline(userId);

package/fesm/controllers/notification.controller.js

@@ -26,7 +26,6 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { createApiController, NOTIFICATION_PERMISSIONS } from '@flusys/nestjs-shared/classes';
-import { NOTIFICATION_MESSAGES } from '../config';
 import { CurrentUser, RequirePermission } from '@flusys/nestjs-shared/decorators';
 import { BulkResponseDto, MessageResponseDto, SingleResponseDto } from '@flusys/nestjs-shared/dtos';
 import { JwtAuthGuard, PermissionGuard } from '@flusys/nestjs-shared/guards';
@@ -34,6 +33,7 @@ import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { Body, Controller, HttpCode, HttpStatus, Inject, Post, UseGuards } from '@nestjs/common';
 import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { plainToInstance } from 'class-transformer';
+import { NOTIFICATION_MESSAGES } from '../config';
 import { CreateNotificationDto, MarkReadDto, NotificationResponseDto, SendBulkNotificationDto, SendNotificationDto, UpdateNotificationDto } from '../dtos';
 import { NotificationHelperService } from '../services/notification-helper.service';
 import { NotificationService } from '../services/notification.service';
@@ -83,11 +83,14 @@ export class NotificationController extends createApiController(CreateNotificati
 }) {
     async markAsRead(dto, user) {
         const notification = await this.service.markAsRead(dto.id, user);
+        const plainOptions = {
+            excludeExtraneousValues: true
+        };
         return {
             success: true,
             message: 'Notification marked as read',
             messageKey: NOTIFICATION_MESSAGES.MARK_READ_SUCCESS,
-            data: plainToInstance(NotificationResponseDto, notification)
+            data: plainToInstance(NotificationResponseDto, notification, plainOptions)
         };
     }
     async markAllAsRead(user) {
@@ -121,11 +124,14 @@ export class NotificationController extends createApiController(CreateNotificati
             data: dto.data,
             companyId: dto.companyId
         });
+        const plainOptions = {
+            excludeExtraneousValues: true
+        };
         return {
             success: true,
             message: 'Notification sent successfully',
             messageKey: NOTIFICATION_MESSAGES.SEND_SUCCESS,
-            data: plainToInstance(NotificationResponseDto, notification)
+            data: plainToInstance(NotificationResponseDto, notification, plainOptions)
         };
     }
     async sendBulkNotification(dto) {
@@ -137,6 +143,9 @@ export class NotificationController extends createApiController(CreateNotificati
             data: dto.data,
             companyId: dto.companyId
         });
+        const plainOptions = {
+            excludeExtraneousValues: true
+        };
         return {
             success: true,
             message: `${notifications.length} notifications sent successfully`,
@@ -144,7 +153,7 @@ export class NotificationController extends createApiController(CreateNotificati
             messageVariables: {
                 count: notifications.length
             },
-            data: notifications.map((n)=>plainToInstance(NotificationResponseDto, n)),
+            data: notifications.map((n)=>plainToInstance(NotificationResponseDto, n, plainOptions)),
             meta: {
                 count: notifications.length,
                 total: dto.userIds.length

package/fesm/dtos/notification.dto.js

@@ -20,10 +20,10 @@ 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 { NotificationType } from '@flusys/nestjs-shared/enums';
 import { ApiProperty, ApiPropertyOptional, IntersectionType, OmitType, PartialType } from '@nestjs/swagger';
 import { Expose } from 'class-transformer';
 import { IsEnum, IsNotEmpty, IsObject, IsOptional, IsString, IsUUID, MaxLength } from 'class-validator';
-import { NotificationType } from '@flusys/nestjs-shared/enums';
 let NotificationContentDto = class NotificationContentDto {
     constructor(){
         _define_property(this, "title", void 0);
@@ -140,59 +140,106 @@ export class NotificationResponseDto {
 }
 _ts_decorate([
     Expose(),
-    ApiProperty(),
+    ApiProperty({
+        description: 'Unique identifier of the notification',
+        example: '018e1b2c-3d4e-5f6a-7b8c-9d0e1f2a3b4c'
+    }),
     _ts_metadata("design:type", String)
 ], NotificationResponseDto.prototype, "id", void 0);
 _ts_decorate([
     Expose(),
-    ApiProperty(),
+    ApiProperty({
+        description: 'ID of the user this notification belongs to',
+        example: '018e1b2c-3d4e-5f6a-7b8c-9d0e1f2a3b4c'
+    }),
     _ts_metadata("design:type", String)
 ], NotificationResponseDto.prototype, "userId", void 0);
 _ts_decorate([
     Expose(),
     ApiProperty({
-        enum: NotificationType
+        description: 'Category of the notification',
+        enum: NotificationType,
+        example: NotificationType.SUCCESS
     }),
-    _ts_metadata("design:type", String)
+    _ts_metadata("design:type", typeof NotificationType === "undefined" ? Object : NotificationType)
 ], NotificationResponseDto.prototype, "type", void 0);
 _ts_decorate([
     Expose(),
-    ApiProperty(),
+    ApiProperty({
+        description: 'Short title of the notification',
+        example: 'Your export is ready'
+    }),
     _ts_metadata("design:type", String)
 ], NotificationResponseDto.prototype, "title", void 0);
 _ts_decorate([
     Expose(),
-    ApiPropertyOptional(),
+    ApiPropertyOptional({
+        description: 'Optional longer body text for the notification',
+        example: 'Your CSV export has finished processing and is ready to download.',
+        nullable: true
+    }),
     _ts_metadata("design:type", Object)
 ], NotificationResponseDto.prototype, "message", void 0);
 _ts_decorate([
     Expose(),
-    ApiPropertyOptional(),
+    ApiPropertyOptional({
+        description: 'Arbitrary JSON payload attached to the notification',
+        type: 'object',
+        additionalProperties: true,
+        nullable: true,
+        example: {
+            exportId: 'abc123',
+            fileUrl: 'https://cdn.example.com/export.csv'
+        }
+    }),
     _ts_metadata("design:type", Object)
 ], NotificationResponseDto.prototype, "data", void 0);
 _ts_decorate([
     Expose(),
-    ApiProperty(),
+    ApiProperty({
+        description: 'Whether the user has read this notification',
+        example: false
+    }),
     _ts_metadata("design:type", Boolean)
 ], NotificationResponseDto.prototype, "isRead", void 0);
 _ts_decorate([
     Expose(),
-    ApiPropertyOptional(),
+    ApiPropertyOptional({
+        description: 'Timestamp when the notification was marked as read; null if unread',
+        type: 'string',
+        format: 'date-time',
+        nullable: true,
+        example: '2024-03-15T10:30:00.000Z'
+    }),
     _ts_metadata("design:type", Object)
 ], NotificationResponseDto.prototype, "readAt", void 0);
 _ts_decorate([
     Expose(),
-    ApiPropertyOptional(),
+    ApiPropertyOptional({
+        description: 'Company scope for the notification; null for personal notifications',
+        example: '018e1b2c-3d4e-5f6a-7b8c-9d0e1f2a3b4c',
+        nullable: true
+    }),
     _ts_metadata("design:type", Object)
 ], NotificationResponseDto.prototype, "companyId", void 0);
 _ts_decorate([
     Expose(),
-    ApiProperty(),
+    ApiProperty({
+        description: 'Timestamp when the notification was created',
+        type: 'string',
+        format: 'date-time',
+        example: '2024-03-15T10:00:00.000Z'
+    }),
     _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
 ], NotificationResponseDto.prototype, "createdAt", void 0);
 _ts_decorate([
     Expose(),
-    ApiProperty(),
+    ApiProperty({
+        description: 'Timestamp when the notification was last updated',
+        type: 'string',
+        format: 'date-time',
+        example: '2024-03-15T10:30:00.000Z'
+    }),
     _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
 ], NotificationResponseDto.prototype, "updatedAt", void 0);
 export class UnreadCountResponseDto {
@@ -202,7 +249,11 @@ export class UnreadCountResponseDto {
 }
 _ts_decorate([
     Expose(),
-    ApiProperty(),
+    ApiProperty({
+        description: 'Total number of unread notifications for the user',
+        example: 5,
+        minimum: 0
+    }),
     _ts_metadata("design:type", Number)
 ], UnreadCountResponseDto.prototype, "count", void 0);
 export class SendNotificationDto extends IntersectionType(UserIdDto, NotificationContentDto) {

package/fesm/modules/notification.module.js

@@ -27,10 +27,6 @@ const ADAPTER_PROVIDER = {
 };
 export class NotificationModule {
     static forRoot(options) {
-        const enableRealtime = options.config?.enableRealtime !== false;
-        const gatewayProviders = enableRealtime ? [
-            NotificationGateway
-        ] : [];
         return {
             module: NotificationModule,
             global: options.global ?? false,
@@ -41,13 +37,13 @@ export class NotificationModule {
             controllers: options.includeController !== false ? CONTROLLERS : [],
             providers: [
                 ...this.buildProviders(options),
-                ...gatewayProviders,
+                NotificationGateway,
                 NotificationAdapter,
                 ADAPTER_PROVIDER
             ],
             exports: [
                 ...EXPORTED_SERVICES,
-                ...gatewayProviders,
+                NotificationGateway,
                 NOTIFICATION_ADAPTER
             ]
         };

package/fesm/services/notification-config.service.js

@@ -38,9 +38,6 @@ export class NotificationConfigService {
     isMultiTenant() {
         return this.getDatabaseMode() === 'multi-tenant';
     }
-    isRealtimeEnabled() {
-        return this.options.config?.enableRealtime !== false;
-    }
     getJwtSecret() {
         return this.options.config?.jwtSecret;
     }

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

@@ -26,8 +26,7 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
-import { SYSTEM_MESSAGES } from '@flusys/nestjs-shared/constants';
-import { Inject, Injectable, InternalServerErrorException, Optional, Scope } from '@nestjs/common';
+import { Inject, Injectable, Optional, Scope } from '@nestjs/common';
 import { REQUEST } from '@nestjs/core';
 import { Request } from 'express';
 import { NotificationConfigService } from './notification-config.service';
@@ -58,50 +57,6 @@ export class NotificationDataSourceProvider extends MultiTenantDataSourceService
         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 InternalServerErrorException({
-                message: 'No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.',
-                messageKey: SYSTEM_MESSAGES.DATABASE_CONFIG_NOT_AVAILABLE
-            });
-        }
-        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), this.configService = configService;
     }

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

@@ -25,100 +25,78 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { Inject, Injectable, Optional } from '@nestjs/common';
+import { INotificationBulkSendOptions, INotificationSendOptions, LogAction } from '@flusys/nestjs-shared';
 import { HybridCache } from '@flusys/nestjs-shared/classes';
-import { LogAction } from '@flusys/nestjs-shared';
+import { NotificationType } from '@flusys/nestjs-shared/enums';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { Inject, Injectable, Optional } from '@nestjs/common';
+import { Notification, NotificationWithCompany } from '../entities';
+import { NotificationGateway } from '../gateways';
 import { NotificationConfigService } from './notification-config.service';
 import { NotificationDataSourceProvider } from './notification-datasource.provider';
-import { NotificationGateway } from '../gateways';
-import { Notification, NotificationWithCompany } from '../entities';
-import { NotificationType } from '@flusys/nestjs-shared/enums';
 export 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() ? NotificationWithCompany : Notification;
-        return ds.getRepository(EntityClass);
-    }
     async send(options) {
-        const { userId, title, message = null, type = 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 entity = this.buildEntity(options.userId, options);
         const saved = await repo.save(entity);
         await this.clearCache();
-        this.emitRealtime(saved);
+        this.emitToUser(saved, options.realtime !== false);
         return saved;
     }
     async sendToMany(options) {
-        const { userIds, title, message = null, type = 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 entities = options.userIds.map((userId)=>this.buildEntity(userId, options));
         const saved = await repo.save(entities);
         await this.clearCache();
-        for (const notification of saved){
-            this.emitRealtime(notification);
+        if (options.realtime !== false) {
+            setImmediate(()=>{
+                for (const notification of saved){
+                    this.emitToUser(notification, true);
+                }
+            });
         }
         return saved;
     }
-    async sendToCompany(companyId, title, message, type = NotificationType.INFO, data) {
-        if (!this.configService.isCompanyFeatureEnabled()) {
-            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);
-        }
-    }
     isUserOnline(userId) {
         return this.gateway?.isUserOnline(userId) ?? false;
     }
     getOnlineUserCount() {
         return this.gateway?.getOnlineUserCount() ?? 0;
     }
-    emitRealtime(notification) {
-        if (!this.configService.isRealtimeEnabled() || !this.gateway) {
+    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() ? NotificationWithCompany : Notification;
+        return ds.getRepository(EntityClass);
+    }
+    buildEntity(userId, content) {
+        const entity = {
+            userId,
+            type: content.type ?? NotificationType.INFO,
+            title: content.title,
+            message: content.message ?? null,
+            data: content.data ?? null,
+            isRead: false
+        };
+        if (this.configService.isCompanyFeatureEnabled() && content.companyId) {
+            entity.companyId = content.companyId;
+        }
+        return entity;
+    }
+    emitToUser(notification, realtime) {
+        if (!realtime || !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);
         }
     }
@@ -133,7 +111,7 @@ export class NotificationHelperService {
         };
     }
     async clearCache() {
-        await this.utilsService.clearCache(this.entityName, this.cacheManager);
+        await this.utilsService.clearCache('notification', this.cacheManager);
     }
     constructor(cacheManager, utilsService, configService, dataSourceProvider, gateway){
         _define_property(this, "cacheManager", void 0);
@@ -141,14 +119,12 @@ export class NotificationHelperService {
         _define_property(this, "configService", void 0);
         _define_property(this, "dataSourceProvider", void 0);
         _define_property(this, "gateway", 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.entityName = 'notification';
         this.dataSource = null;
     }
 }
@@ -159,7 +135,7 @@ _ts_decorate([
     }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof SendNotificationOptions === "undefined" ? Object : SendNotificationOptions
+        typeof INotificationSendOptions === "undefined" ? Object : INotificationSendOptions
     ]),
     _ts_metadata("design:returntype", Promise)
 ], NotificationHelperService.prototype, "send", null);
@@ -170,25 +146,10 @@ _ts_decorate([
     }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof SendBulkNotificationOptions === "undefined" ? Object : SendBulkNotificationOptions
+        typeof INotificationBulkSendOptions === "undefined" ? Object : INotificationBulkSendOptions
     ]),
     _ts_metadata("design:returntype", Promise)
 ], NotificationHelperService.prototype, "sendToMany", null);
-_ts_decorate([
-    LogAction({
-        action: 'notification.sendToCompany',
-        module: 'notification'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        String,
-        Object,
-        Object,
-        Object
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], NotificationHelperService.prototype, "sendToCompany", null);
 NotificationHelperService = _ts_decorate([
     Injectable(),
     _ts_param(0, Inject('CACHE_INSTANCE')),