@flusys/nestjs-notification 3.0.1

package/adapters/index.d.ts

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

package/adapters/notification.adapter.d.ts

@@ -0,0 +1,10 @@
+import { INotificationAdapter, NotificationSendOptions, NotificationBulkSendOptions, NotificationType } from '@flusys/nestjs-shared';
+import { NotificationHelperService } from '../services/notification-helper.service';
+export declare class NotificationAdapter implements INotificationAdapter {
+    private readonly notificationHelper;
+    constructor(notificationHelper: NotificationHelperService);
+    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;
+}

package/cjs/adapters/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./notification.adapter"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/cjs/adapters/notification.adapter.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NotificationAdapter", {
+    enumerable: true,
+    get: function() {
+        return NotificationAdapter;
+    }
+});
+const _common = require("@nestjs/common");
+const _notificationhelperservice = require("../services/notification-helper.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 _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 NotificationAdapter = 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([
+    (0, _common.Injectable)(),
+    _ts_param(0, (0, _common.Inject)(_notificationhelperservice.NotificationHelperService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _notificationhelperservice.NotificationHelperService === "undefined" ? Object : _notificationhelperservice.NotificationHelperService
+    ])
+], NotificationAdapter);

package/cjs/config/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./notification.constants"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/cjs/config/notification.constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NOTIFICATION_MODULE_OPTIONS", {
+    enumerable: true,
+    get: function() {
+        return NOTIFICATION_MODULE_OPTIONS;
+    }
+});
+const NOTIFICATION_MODULE_OPTIONS = 'NOTIFICATION_MODULE_OPTIONS';

package/cjs/controllers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./notification.controller"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/cjs/controllers/notification.controller.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NotificationController", {
+    enumerable: true,
+    get: function() {
+        return NotificationController;
+    }
+});
+const _classes = require("@flusys/nestjs-shared/classes");
+const _constants = require("@flusys/nestjs-shared/constants");
+const _decorators = require("@flusys/nestjs-shared/decorators");
+const _dtos = require("@flusys/nestjs-shared/dtos");
+const _guards = require("@flusys/nestjs-shared/guards");
+const _interfaces = require("@flusys/nestjs-shared/interfaces");
+const _common = require("@nestjs/common");
+const _swagger = require("@nestjs/swagger");
+const _classtransformer = require("class-transformer");
+const _dtos1 = require("../dtos");
+const _notificationhelperservice = require("../services/notification-helper.service");
+const _notificationservice = require("../services/notification.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 _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 NotificationController = class NotificationController extends (0, _classes.createApiController)(_dtos1.CreateNotificationDto, _dtos1.UpdateNotificationDto, _dtos1.NotificationResponseDto, {
+    security: {
+        insert: {
+            level: 'permission',
+            permissions: [
+                _constants.NOTIFICATION_PERMISSIONS.CREATE
+            ]
+        },
+        insertMany: {
+            level: 'permission',
+            permissions: [
+                _constants.NOTIFICATION_PERMISSIONS.CREATE
+            ]
+        },
+        getById: {
+            level: 'permission',
+            permissions: [
+                _constants.NOTIFICATION_PERMISSIONS.READ
+            ]
+        },
+        getAll: {
+            level: 'jwt'
+        },
+        update: {
+            level: 'permission',
+            permissions: [
+                _constants.NOTIFICATION_PERMISSIONS.UPDATE
+            ]
+        },
+        updateMany: {
+            level: 'permission',
+            permissions: [
+                _constants.NOTIFICATION_PERMISSIONS.UPDATE
+            ]
+        },
+        delete: {
+            level: 'permission',
+            permissions: [
+                _constants.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: (0, _classtransformer.plainToInstance)(_dtos1.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: (0, _classtransformer.plainToInstance)(_dtos1.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)=>(0, _classtransformer.plainToInstance)(_dtos1.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([
+    (0, _common.Post)('mark-read'),
+    (0, _common.HttpCode)(_common.HttpStatus.OK),
+    (0, _common.UseGuards)(_guards.JwtAuthGuard),
+    (0, _swagger.ApiBearerAuth)(),
+    (0, _swagger.ApiOperation)({
+        summary: 'Mark a notification as read'
+    }),
+    (0, _swagger.ApiBody)({
+        type: _dtos1.MarkReadDto
+    }),
+    (0, _swagger.ApiResponse)({
+        status: 200,
+        description: 'Notification marked as read',
+        type: _dtos.SingleResponseDto
+    }),
+    _ts_param(0, (0, _common.Body)()),
+    _ts_param(1, (0, _decorators.CurrentUser)()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _dtos1.MarkReadDto === "undefined" ? Object : _dtos1.MarkReadDto,
+        typeof _interfaces.ILoggedUserInfo === "undefined" ? Object : _interfaces.ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], NotificationController.prototype, "markAsRead", null);
+_ts_decorate([
+    (0, _common.Post)('mark-all-read'),
+    (0, _common.HttpCode)(_common.HttpStatus.OK),
+    (0, _common.UseGuards)(_guards.JwtAuthGuard),
+    (0, _swagger.ApiBearerAuth)(),
+    (0, _swagger.ApiOperation)({
+        summary: 'Mark all notifications as read'
+    }),
+    (0, _swagger.ApiResponse)({
+        status: 200,
+        description: 'All notifications marked as read',
+        type: _dtos.MessageResponseDto
+    }),
+    _ts_param(0, (0, _decorators.CurrentUser)()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _interfaces.ILoggedUserInfo === "undefined" ? Object : _interfaces.ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], NotificationController.prototype, "markAllAsRead", null);
+_ts_decorate([
+    (0, _common.Post)('unread-count'),
+    (0, _common.HttpCode)(_common.HttpStatus.OK),
+    (0, _common.UseGuards)(_guards.JwtAuthGuard),
+    (0, _swagger.ApiBearerAuth)(),
+    (0, _swagger.ApiOperation)({
+        summary: 'Get unread notification count'
+    }),
+    (0, _swagger.ApiResponse)({
+        status: 200,
+        description: 'Unread count retrieved',
+        type: _dtos.SingleResponseDto
+    }),
+    _ts_param(0, (0, _decorators.CurrentUser)()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _interfaces.ILoggedUserInfo === "undefined" ? Object : _interfaces.ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], NotificationController.prototype, "getUnreadCount", null);
+_ts_decorate([
+    (0, _common.Post)('send'),
+    (0, _common.HttpCode)(_common.HttpStatus.OK),
+    (0, _common.UseGuards)(_guards.JwtAuthGuard, _guards.PermissionGuard),
+    (0, _decorators.RequirePermission)(_constants.NOTIFICATION_PERMISSIONS.CREATE),
+    (0, _swagger.ApiOperation)({
+        summary: 'Send a notification to a user'
+    }),
+    (0, _swagger.ApiBody)({
+        type: _dtos1.SendNotificationDto
+    }),
+    (0, _swagger.ApiResponse)({
+        status: 200,
+        description: 'Notification sent successfully',
+        type: _dtos.SingleResponseDto
+    }),
+    _ts_param(0, (0, _common.Body)()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _dtos1.SendNotificationDto === "undefined" ? Object : _dtos1.SendNotificationDto
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], NotificationController.prototype, "sendNotification", null);
+_ts_decorate([
+    (0, _common.Post)('send-bulk'),
+    (0, _common.HttpCode)(_common.HttpStatus.OK),
+    (0, _common.UseGuards)(_guards.JwtAuthGuard, _guards.PermissionGuard),
+    (0, _decorators.RequirePermission)(_constants.NOTIFICATION_PERMISSIONS.CREATE),
+    (0, _swagger.ApiOperation)({
+        summary: 'Send a notification to multiple users'
+    }),
+    (0, _swagger.ApiBody)({
+        type: _dtos1.SendBulkNotificationDto
+    }),
+    (0, _swagger.ApiResponse)({
+        status: 200,
+        description: 'Notifications sent successfully',
+        type: _dtos.BulkResponseDto
+    }),
+    _ts_param(0, (0, _common.Body)()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _dtos1.SendBulkNotificationDto === "undefined" ? Object : _dtos1.SendBulkNotificationDto
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], NotificationController.prototype, "sendBulkNotification", null);
+NotificationController = _ts_decorate([
+    (0, _swagger.ApiTags)('Notifications'),
+    (0, _swagger.ApiBearerAuth)(),
+    (0, _common.Controller)('notification'),
+    _ts_param(0, (0, _common.Inject)(_notificationservice.NotificationService)),
+    _ts_param(1, (0, _common.Inject)(_notificationhelperservice.NotificationHelperService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _notificationservice.NotificationService === "undefined" ? Object : _notificationservice.NotificationService,
+        typeof _notificationhelperservice.NotificationHelperService === "undefined" ? Object : _notificationhelperservice.NotificationHelperService
+    ])
+], NotificationController);

package/cjs/docs/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./notification-swagger.config"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "notificationSwaggerConfig", {
+    enumerable: true,
+    get: function() {
+        return notificationSwaggerConfig;
+    }
+});
+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/cjs/dtos/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./notification.dto"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}