@flusys/nestjs-notification 3.0.1

package/entities/index.d.ts

@@ -0,0 +1,8 @@
+export * from './notification.entity';
+export * from './notification-with-company.entity';
+import { Notification } from './notification.entity';
+import { NotificationWithCompany } from './notification-with-company.entity';
+export declare const NotificationCoreEntities: (typeof Notification)[];
+export declare const NotificationCompanyEntities: (typeof NotificationWithCompany)[];
+export declare function getNotificationEntitiesByConfig(enableCompanyFeature: boolean): any[];
+export { Notification as NotificationBase } from './notification.entity';

package/entities/notification-with-company.entity.d.ts

@@ -0,0 +1,4 @@
+import { Notification } from './notification.entity';
+export declare class NotificationWithCompany extends Notification {
+    companyId: string | null;
+}

package/entities/notification.entity.d.ts

@@ -0,0 +1,10 @@
+import { Identity } from '@flusys/nestjs-shared/entities';
+export declare class Notification extends Identity {
+    userId: string;
+    type: string;
+    title: string;
+    message: string | null;
+    data: Record<string, unknown> | null;
+    isRead: boolean;
+    readAt: Date | null;
+}

package/fesm/adapters/index.js

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

package/fesm/adapters/notification.adapter.js

@@ -0,0 +1,69 @@
+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);
+    };
+}
+import { Injectable, Inject } 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
+        });
+    }
+    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);
+    }
+    isUserOnline(userId) {
+        return this.notificationHelper.isUserOnline(userId);
+    }
+    constructor(notificationHelper){
+        _define_property(this, "notificationHelper", void 0);
+        this.notificationHelper = notificationHelper;
+    }
+}
+NotificationAdapter = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Inject(NotificationHelperService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof NotificationHelperService === "undefined" ? Object : NotificationHelperService
+    ])
+], NotificationAdapter);

package/fesm/config/index.js

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

package/fesm/config/notification.constants.js

@@ -0,0 +1 @@
+export const NOTIFICATION_MODULE_OPTIONS = 'NOTIFICATION_MODULE_OPTIONS';

package/fesm/controllers/index.js

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

package/fesm/controllers/notification.controller.js

@@ -0,0 +1,268 @@
+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);
+    };
+}
+import { createApiController } from '@flusys/nestjs-shared/classes';
+import { NOTIFICATION_PERMISSIONS } from '@flusys/nestjs-shared/constants';
+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';
+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 { CreateNotificationDto, MarkReadDto, NotificationResponseDto, SendBulkNotificationDto, SendNotificationDto, UpdateNotificationDto } from '../dtos';
+import { NotificationHelperService } from '../services/notification-helper.service';
+import { NotificationService } from '../services/notification.service';
+export class NotificationController extends createApiController(CreateNotificationDto, UpdateNotificationDto, NotificationResponseDto, {
+    security: {
+        insert: {
+            level: 'permission',
+            permissions: [
+                NOTIFICATION_PERMISSIONS.CREATE
+            ]
+        },
+        insertMany: {
+            level: 'permission',
+            permissions: [
+                NOTIFICATION_PERMISSIONS.CREATE
+            ]
+        },
+        getById: {
+            level: 'permission',
+            permissions: [
+                NOTIFICATION_PERMISSIONS.READ
+            ]
+        },
+        getAll: {
+            level: 'jwt'
+        },
+        update: {
+            level: 'permission',
+            permissions: [
+                NOTIFICATION_PERMISSIONS.UPDATE
+            ]
+        },
+        updateMany: {
+            level: 'permission',
+            permissions: [
+                NOTIFICATION_PERMISSIONS.UPDATE
+            ]
+        },
+        delete: {
+            level: 'permission',
+            permissions: [
+                NOTIFICATION_PERMISSIONS.DELETE
+            ]
+        }
+    }
+}) {
+    async markAsRead(dto, user) {
+        const notification = await this.service.markAsRead(dto.id, user);
+        return {
+            success: true,
+            message: 'Notification marked as read',
+            data: plainToInstance(NotificationResponseDto, notification)
+        };
+    }
+    async markAllAsRead(user) {
+        const count = await this.service.markAllAsRead(user);
+        return {
+            success: true,
+            message: `${count} notifications marked as read`
+        };
+    }
+    async getUnreadCount(user) {
+        const count = await this.service.getUnreadCount(user);
+        return {
+            success: true,
+            message: 'Unread count retrieved',
+            data: {
+                count
+            }
+        };
+    }
+    async sendNotification(dto) {
+        const notification = await this.notificationHelper.send({
+            userId: dto.userId,
+            title: dto.title,
+            message: dto.message,
+            type: dto.type,
+            data: dto.data,
+            companyId: dto.companyId
+        });
+        return {
+            success: true,
+            message: 'Notification sent successfully',
+            data: plainToInstance(NotificationResponseDto, notification)
+        };
+    }
+    async sendBulkNotification(dto) {
+        const notifications = await this.notificationHelper.sendToMany({
+            userIds: dto.userIds,
+            title: dto.title,
+            message: dto.message,
+            type: dto.type,
+            data: dto.data,
+            companyId: dto.companyId
+        });
+        return {
+            success: true,
+            message: `${notifications.length} notifications sent successfully`,
+            data: notifications.map((n)=>plainToInstance(NotificationResponseDto, n)),
+            meta: {
+                count: notifications.length,
+                total: dto.userIds.length
+            }
+        };
+    }
+    constructor(service, notificationHelper){
+        super(service), _define_property(this, "service", void 0), _define_property(this, "notificationHelper", void 0), this.service = service, this.notificationHelper = notificationHelper;
+    }
+}
+_ts_decorate([
+    Post('mark-read'),
+    HttpCode(HttpStatus.OK),
+    UseGuards(JwtAuthGuard),
+    ApiBearerAuth(),
+    ApiOperation({
+        summary: 'Mark a notification as read'
+    }),
+    ApiBody({
+        type: MarkReadDto
+    }),
+    ApiResponse({
+        status: 200,
+        description: 'Notification marked as read',
+        type: SingleResponseDto
+    }),
+    _ts_param(0, Body()),
+    _ts_param(1, CurrentUser()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof MarkReadDto === "undefined" ? Object : MarkReadDto,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], NotificationController.prototype, "markAsRead", null);
+_ts_decorate([
+    Post('mark-all-read'),
+    HttpCode(HttpStatus.OK),
+    UseGuards(JwtAuthGuard),
+    ApiBearerAuth(),
+    ApiOperation({
+        summary: 'Mark all notifications as read'
+    }),
+    ApiResponse({
+        status: 200,
+        description: 'All notifications marked as read',
+        type: MessageResponseDto
+    }),
+    _ts_param(0, CurrentUser()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], NotificationController.prototype, "markAllAsRead", null);
+_ts_decorate([
+    Post('unread-count'),
+    HttpCode(HttpStatus.OK),
+    UseGuards(JwtAuthGuard),
+    ApiBearerAuth(),
+    ApiOperation({
+        summary: 'Get unread notification count'
+    }),
+    ApiResponse({
+        status: 200,
+        description: 'Unread count retrieved',
+        type: SingleResponseDto
+    }),
+    _ts_param(0, CurrentUser()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], NotificationController.prototype, "getUnreadCount", null);
+_ts_decorate([
+    Post('send'),
+    HttpCode(HttpStatus.OK),
+    UseGuards(JwtAuthGuard, PermissionGuard),
+    RequirePermission(NOTIFICATION_PERMISSIONS.CREATE),
+    ApiOperation({
+        summary: 'Send a notification to a user'
+    }),
+    ApiBody({
+        type: SendNotificationDto
+    }),
+    ApiResponse({
+        status: 200,
+        description: 'Notification sent successfully',
+        type: SingleResponseDto
+    }),
+    _ts_param(0, Body()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof SendNotificationDto === "undefined" ? Object : SendNotificationDto
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], NotificationController.prototype, "sendNotification", null);
+_ts_decorate([
+    Post('send-bulk'),
+    HttpCode(HttpStatus.OK),
+    UseGuards(JwtAuthGuard, PermissionGuard),
+    RequirePermission(NOTIFICATION_PERMISSIONS.CREATE),
+    ApiOperation({
+        summary: 'Send a notification to multiple users'
+    }),
+    ApiBody({
+        type: SendBulkNotificationDto
+    }),
+    ApiResponse({
+        status: 200,
+        description: 'Notifications sent successfully',
+        type: BulkResponseDto
+    }),
+    _ts_param(0, Body()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof SendBulkNotificationDto === "undefined" ? Object : SendBulkNotificationDto
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], NotificationController.prototype, "sendBulkNotification", null);
+NotificationController = _ts_decorate([
+    ApiTags('Notifications'),
+    ApiBearerAuth(),
+    Controller('notification'),
+    _ts_param(0, Inject(NotificationService)),
+    _ts_param(1, Inject(NotificationHelperService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof NotificationService === "undefined" ? Object : NotificationService,
+        typeof NotificationHelperService === "undefined" ? Object : NotificationHelperService
+    ])
+], NotificationController);

package/fesm/docs/index.js

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

package/fesm/docs/notification-swagger.config.js

@@ -0,0 +1,51 @@
+export function notificationSwaggerConfig() {
+    return {
+        title: 'Notification API',
+        description: `
+## Notification API
+
+Real-time notification system with WebSocket support.
+
+### Features
+- Push notifications to users
+- Mark notifications as read
+- Unread count tracking
+- Real-time delivery via WebSocket
+- Bulk notification sending
+
+### Endpoints
+
+#### User Notifications
+- \`POST /notification/get-all\` - Get user's notifications (paginated, sorted by newest)
+- \`POST /notification/get/:id\` - Get single notification
+- \`POST /notification/mark-read\` - Mark notification as read
+- \`POST /notification/mark-all-read\` - Mark all notifications as read
+- \`POST /notification/unread-count\` - Get unread notification count
+
+#### Admin/System
+- \`POST /notification/send\` - Send notification to a user
+- \`POST /notification/send-bulk\` - Send notification to multiple users
+
+### WebSocket Events
+
+Connect to WebSocket with JWT authentication:
+\`\`\`
+ws://localhost:2002/notification?token=<jwt>
+\`\`\`
+
+**Events:**
+- \`notification:new\` - New notification received
+- \`notification:read\` - Notification marked as read
+- \`notification:read-all\` - All notifications marked as read
+
+### Notification Types
+- \`info\` - General information
+- \`success\` - Success message
+- \`warning\` - Warning message
+- \`error\` - Error message
+    `,
+        version: '1.0',
+        path: 'api/docs/notification',
+        bearerAuth: true
+    };
+}

package/fesm/dtos/index.js

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

package/fesm/dtos/notification.dto.js

@@ -0,0 +1,211 @@
+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);
+}
+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);
+        _define_property(this, "message", void 0);
+        _define_property(this, "type", void 0);
+        _define_property(this, "data", void 0);
+        _define_property(this, "companyId", void 0);
+    }
+};
+_ts_decorate([
+    ApiProperty({
+        maxLength: 255
+    }),
+    IsNotEmpty(),
+    IsString(),
+    MaxLength(255),
+    _ts_metadata("design:type", String)
+], NotificationContentDto.prototype, "title", void 0);
+_ts_decorate([
+    ApiPropertyOptional(),
+    IsOptional(),
+    IsString(),
+    _ts_metadata("design:type", String)
+], NotificationContentDto.prototype, "message", void 0);
+_ts_decorate([
+    ApiPropertyOptional({
+        enum: NotificationType,
+        default: NotificationType.INFO
+    }),
+    IsOptional(),
+    IsEnum(NotificationType),
+    _ts_metadata("design:type", typeof NotificationType === "undefined" ? Object : NotificationType)
+], NotificationContentDto.prototype, "type", void 0);
+_ts_decorate([
+    ApiPropertyOptional(),
+    IsOptional(),
+    IsObject(),
+    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], NotificationContentDto.prototype, "data", void 0);
+_ts_decorate([
+    ApiPropertyOptional(),
+    IsOptional(),
+    IsUUID(),
+    _ts_metadata("design:type", String)
+], NotificationContentDto.prototype, "companyId", void 0);
+let UserIdDto = class UserIdDto {
+    constructor(){
+        _define_property(this, "userId", void 0);
+    }
+};
+_ts_decorate([
+    ApiProperty(),
+    IsNotEmpty(),
+    IsUUID(),
+    _ts_metadata("design:type", String)
+], UserIdDto.prototype, "userId", void 0);
+let UserIdsDto = class UserIdsDto {
+    constructor(){
+        _define_property(this, "userIds", void 0);
+    }
+};
+_ts_decorate([
+    ApiProperty({
+        type: [
+            String
+        ]
+    }),
+    IsNotEmpty(),
+    IsUUID('4', {
+        each: true
+    }),
+    _ts_metadata("design:type", Array)
+], UserIdsDto.prototype, "userIds", void 0);
+export class CreateNotificationDto extends IntersectionType(UserIdDto, NotificationContentDto) {
+}
+export class UpdateNotificationDto extends PartialType(OmitType(CreateNotificationDto, [
+    'userId'
+])) {
+    constructor(...args){
+        super(...args), _define_property(this, "id", void 0);
+    }
+}
+_ts_decorate([
+    ApiProperty(),
+    IsUUID(),
+    IsNotEmpty(),
+    _ts_metadata("design:type", String)
+], UpdateNotificationDto.prototype, "id", void 0);
+export class MarkReadDto {
+    constructor(){
+        _define_property(this, "id", void 0);
+    }
+}
+_ts_decorate([
+    ApiProperty(),
+    IsUUID(),
+    IsNotEmpty(),
+    _ts_metadata("design:type", String)
+], MarkReadDto.prototype, "id", void 0);
+export class NotificationResponseDto {
+    constructor(){
+        _define_property(this, "id", void 0);
+        _define_property(this, "userId", void 0);
+        _define_property(this, "type", void 0);
+        _define_property(this, "title", void 0);
+        _define_property(this, "message", void 0);
+        _define_property(this, "data", void 0);
+        _define_property(this, "isRead", void 0);
+        _define_property(this, "readAt", void 0);
+        _define_property(this, "companyId", void 0);
+        _define_property(this, "createdAt", void 0);
+        _define_property(this, "updatedAt", void 0);
+    }
+}
+_ts_decorate([
+    Expose(),
+    ApiProperty(),
+    _ts_metadata("design:type", String)
+], NotificationResponseDto.prototype, "id", void 0);
+_ts_decorate([
+    Expose(),
+    ApiProperty(),
+    _ts_metadata("design:type", String)
+], NotificationResponseDto.prototype, "userId", void 0);
+_ts_decorate([
+    Expose(),
+    ApiProperty({
+        enum: NotificationType
+    }),
+    _ts_metadata("design:type", String)
+], NotificationResponseDto.prototype, "type", void 0);
+_ts_decorate([
+    Expose(),
+    ApiProperty(),
+    _ts_metadata("design:type", String)
+], NotificationResponseDto.prototype, "title", void 0);
+_ts_decorate([
+    Expose(),
+    ApiPropertyOptional(),
+    _ts_metadata("design:type", Object)
+], NotificationResponseDto.prototype, "message", void 0);
+_ts_decorate([
+    Expose(),
+    ApiPropertyOptional(),
+    _ts_metadata("design:type", Object)
+], NotificationResponseDto.prototype, "data", void 0);
+_ts_decorate([
+    Expose(),
+    ApiProperty(),
+    _ts_metadata("design:type", Boolean)
+], NotificationResponseDto.prototype, "isRead", void 0);
+_ts_decorate([
+    Expose(),
+    ApiPropertyOptional(),
+    _ts_metadata("design:type", Object)
+], NotificationResponseDto.prototype, "readAt", void 0);
+_ts_decorate([
+    Expose(),
+    ApiPropertyOptional(),
+    _ts_metadata("design:type", Object)
+], NotificationResponseDto.prototype, "companyId", void 0);
+_ts_decorate([
+    Expose(),
+    ApiProperty(),
+    _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], NotificationResponseDto.prototype, "createdAt", void 0);
+_ts_decorate([
+    Expose(),
+    ApiProperty(),
+    _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], NotificationResponseDto.prototype, "updatedAt", void 0);
+export class UnreadCountResponseDto {
+    constructor(){
+        _define_property(this, "count", void 0);
+    }
+}
+_ts_decorate([
+    Expose(),
+    ApiProperty(),
+    _ts_metadata("design:type", Number)
+], UnreadCountResponseDto.prototype, "count", void 0);
+export class SendNotificationDto extends IntersectionType(UserIdDto, NotificationContentDto) {
+}
+export class SendBulkNotificationDto extends IntersectionType(UserIdsDto, NotificationContentDto) {
+}

package/fesm/entities/index.js

@@ -0,0 +1,14 @@
+export * from './notification.entity';
+export * from './notification-with-company.entity';
+import { Notification } from './notification.entity';
+import { NotificationWithCompany } from './notification-with-company.entity';
+export const NotificationCoreEntities = [
+    Notification
+];
+export const NotificationCompanyEntities = [
+    NotificationWithCompany
+];
+export function getNotificationEntitiesByConfig(enableCompanyFeature) {
+    return enableCompanyFeature ? NotificationCompanyEntities : NotificationCoreEntities;
+}
+export { Notification as NotificationBase } from './notification.entity';