@brightchain/brightchain-api-lib 0.23.25 → 0.24.1

package/src/lib/services/brighthub/notificationService.js

@@ -0,0 +1,768 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationService = void 0;
+exports.createNotificationService = createNotificationService;
+const brighthub_lib_1 = require("@brightchain/brighthub-lib");
+const crypto_1 = require("crypto");
+// ═══════════════════════════════════════════════════════
+// Notification type → category mapping
+// ═══════════════════════════════════════════════════════
+/**
+ * Maps each NotificationType to its NotificationCategory.
+ *
+ * Req 55.2 – Social: likes, reposts, quotes, replies, mentions
+ * Req 55.3 – Messages: new messages, message requests, message reactions
+ * Req 55.4 – Connections: new followers, follow requests, reconnect reminders
+ * Req 55.5 – System: account alerts, security notifications, feature announcements
+ */
+const NOTIFICATION_TYPE_CATEGORY_MAP = {
+    // Social (Req 55.2)
+    [brighthub_lib_1.NotificationType.Like]: brighthub_lib_1.NotificationCategory.Social,
+    [brighthub_lib_1.NotificationType.Reply]: brighthub_lib_1.NotificationCategory.Social,
+    [brighthub_lib_1.NotificationType.Mention]: brighthub_lib_1.NotificationCategory.Social,
+    [brighthub_lib_1.NotificationType.Repost]: brighthub_lib_1.NotificationCategory.Social,
+    [brighthub_lib_1.NotificationType.Quote]: brighthub_lib_1.NotificationCategory.Social,
+    // Connections (Req 55.4)
+    [brighthub_lib_1.NotificationType.Follow]: brighthub_lib_1.NotificationCategory.Connections,
+    [brighthub_lib_1.NotificationType.FollowRequest]: brighthub_lib_1.NotificationCategory.Connections,
+    [brighthub_lib_1.NotificationType.ReconnectReminder]: brighthub_lib_1.NotificationCategory.Connections,
+    // Messages (Req 55.3)
+    [brighthub_lib_1.NotificationType.NewMessage]: brighthub_lib_1.NotificationCategory.Messages,
+    [brighthub_lib_1.NotificationType.MessageRequest]: brighthub_lib_1.NotificationCategory.Messages,
+    [brighthub_lib_1.NotificationType.MessageReaction]: brighthub_lib_1.NotificationCategory.Messages,
+    // System (Req 55.5)
+    [brighthub_lib_1.NotificationType.SystemAlert]: brighthub_lib_1.NotificationCategory.System,
+    [brighthub_lib_1.NotificationType.SecurityAlert]: brighthub_lib_1.NotificationCategory.System,
+    [brighthub_lib_1.NotificationType.FeatureAnnouncement]: brighthub_lib_1.NotificationCategory.System,
+};
+// ═══════════════════════════════════════════════════════
+// NotificationService Implementation
+// ═══════════════════════════════════════════════════════
+/**
+ * Notification_Service implementation
+ * Handles notification CRUD, preferences, grouping, and real-time delivery
+ * @see Requirements: 9.1-9.7, 54.1-54.8
+ */
+class NotificationService {
+    notificationsCollection;
+    preferencesCollection;
+    groupsCollection;
+    listMembersCollection;
+    connectionMetadataCollection;
+    categoryAssignmentsCollection;
+    connectionInteractionsCollection;
+    constructor(application) {
+        this.notificationsCollection = application.getModel('brighthub_notifications');
+        this.preferencesCollection =
+            application.getModel('brighthub_notification_preferences');
+        this.groupsCollection = application.getModel('brighthub_notification_groups');
+        this.listMembersCollection =
+            application.getModel('brighthub_connection_list_members');
+        this.connectionMetadataCollection =
+            application.getModel('brighthub_connection_metadata');
+        this.categoryAssignmentsCollection =
+            application.getModel('brighthub_connection_category_assignments');
+        this.connectionInteractionsCollection =
+            application.getModel('brighthub_connection_interactions');
+    }
+    // ═══════════════════════════════════════════════════════
+    // Private helpers
+    // ═══════════════════════════════════════════════════════
+    clampLimit(limit) {
+        const l = limit ?? brighthub_lib_1.DEFAULT_NOTIFICATION_PAGE_LIMIT;
+        return Math.min(Math.max(1, l), brighthub_lib_1.MAX_NOTIFICATION_PAGE_LIMIT);
+    }
+    recordToNotification(record) {
+        return {
+            _id: record._id,
+            recipientId: record.recipientId,
+            type: record.type,
+            category: record.category,
+            actorId: record.actorId,
+            targetId: record.targetId,
+            content: record.content,
+            clickThroughUrl: record.clickThroughUrl,
+            groupId: record.groupId,
+            isRead: record.isRead,
+            createdAt: record.createdAt,
+        };
+    }
+    getCategoryForType(type) {
+        return NOTIFICATION_TYPE_CATEGORY_MAP[type] ?? brighthub_lib_1.NotificationCategory.System;
+    }
+    /**
+     * Build default notification preferences for a user.
+     * All categories enabled, all channels enabled, no quiet hours, no DND, sound on.
+     */
+    buildDefaultPreferences(userId) {
+        const defaultChannels = {
+            [brighthub_lib_1.NotificationChannel.InApp]: true,
+            [brighthub_lib_1.NotificationChannel.Email]: true,
+            [brighthub_lib_1.NotificationChannel.Push]: true,
+        };
+        const defaultCategorySettings = {
+            [brighthub_lib_1.NotificationCategory.Social]: {
+                enabled: true,
+                channels: { ...defaultChannels },
+            },
+            [brighthub_lib_1.NotificationCategory.Messages]: {
+                enabled: true,
+                channels: { ...defaultChannels },
+            },
+            [brighthub_lib_1.NotificationCategory.Connections]: {
+                enabled: true,
+                channels: { ...defaultChannels },
+            },
+            [brighthub_lib_1.NotificationCategory.System]: {
+                enabled: true,
+                channels: { ...defaultChannels },
+            },
+        };
+        return {
+            userId,
+            categorySettings: defaultCategorySettings,
+            channelSettings: { ...defaultChannels },
+            soundEnabled: true,
+        };
+    }
+    /**
+     * Get existing preferences from DB or create and persist defaults.
+     * Req 56.11: Store preferences in user profile and sync across devices.
+     */
+    async getOrCreateDefaultPreferences(userId) {
+        const existing = await this.preferencesCollection
+            .findOne({ userId })
+            .exec();
+        if (existing) {
+            return this.recordToPreferences(existing);
+        }
+        // Create default preferences and persist
+        const defaults = this.buildDefaultPreferences(userId);
+        const now = new Date().toISOString();
+        const record = {
+            _id: (0, crypto_1.randomUUID)(),
+            userId,
+            categorySettings: defaults.categorySettings,
+            channelSettings: defaults.channelSettings,
+            soundEnabled: defaults.soundEnabled,
+            updatedAt: now,
+        };
+        await this.preferencesCollection.create(record);
+        return defaults;
+    }
+    /**
+     * Convert a DB record to IBaseNotificationPreferences<string>.
+     */
+    recordToPreferences(record) {
+        const prefs = {
+            userId: record.userId,
+            categorySettings: record.categorySettings,
+            channelSettings: record.channelSettings,
+            soundEnabled: record.soundEnabled,
+        };
+        if (record.quietHours) {
+            prefs.quietHours = record.quietHours;
+        }
+        if (record.dndConfig) {
+            prefs.dndConfig = record.dndConfig;
+        }
+        return prefs;
+    }
+    /**
+     * Check if the current time falls within the quiet hours window.
+     * Req 56.5: Suppress in-app notifications during quiet hours.
+     * Req 56.6: Quiet hours with start/end times and timezone.
+     */
+    isWithinQuietHours(config) {
+        if (!config.enabled) {
+            return false;
+        }
+        // Parse HH:mm times
+        const parseTime = (timeStr) => {
+            const match = /^(\d{2}):(\d{2})$/.exec(timeStr);
+            if (!match)
+                return null;
+            return { hours: parseInt(match[1], 10), minutes: parseInt(match[2], 10) };
+        };
+        const start = parseTime(config.startTime);
+        const end = parseTime(config.endTime);
+        if (!start || !end)
+            return false;
+        // Get current time in the specified timezone
+        let nowHours;
+        let nowMinutes;
+        try {
+            const nowInTz = new Date().toLocaleString('en-US', {
+                timeZone: config.timezone,
+                hour12: false,
+                hour: '2-digit',
+                minute: '2-digit',
+            });
+            // Format: "HH:MM"
+            const parts = nowInTz.split(':');
+            nowHours = parseInt(parts[0], 10);
+            nowMinutes = parseInt(parts[1], 10);
+        }
+        catch {
+            // Invalid timezone — treat as not within quiet hours
+            return false;
+        }
+        const nowTotal = nowHours * 60 + nowMinutes;
+        const startTotal = start.hours * 60 + start.minutes;
+        const endTotal = end.hours * 60 + end.minutes;
+        // Handle overnight quiet hours (e.g., 22:00 - 07:00)
+        if (startTotal <= endTotal) {
+            return nowTotal >= startTotal && nowTotal < endTotal;
+        }
+        else {
+            return nowTotal >= startTotal || nowTotal < endTotal;
+        }
+    }
+    /**
+     * Check if Do Not Disturb is currently active.
+     * Req 56.7: DND suppresses all non-critical notifications.
+     * Req 56.8: DND duration options.
+     */
+    isDndActive(config) {
+        if (!config.enabled) {
+            return false;
+        }
+        // If there's an expiration, check if it has passed
+        if (config.expiresAt) {
+            const expiresAt = new Date(config.expiresAt);
+            if (new Date() >= expiresAt) {
+                return false;
+            }
+        }
+        // Enabled with no expiration (permanent) or not yet expired
+        return true;
+    }
+    /**
+     * Check if a notification type is critical (should bypass DND/quiet hours).
+     * Req 56.9: Critical system notifications delivered even during DND.
+     */
+    isCriticalNotificationType(type) {
+        return (type === brighthub_lib_1.NotificationType.SecurityAlert ||
+            type === brighthub_lib_1.NotificationType.SystemAlert);
+    }
+    // ═══════════════════════════════════════════════════════
+    // Notification CRUD (Req 9.1-9.7, 54.1-54.8)
+    // ═══════════════════════════════════════════════════════
+    async createNotification(recipientId, type, actorId, options) {
+        if (!recipientId || !actorId) {
+            throw new brighthub_lib_1.NotificationServiceError(brighthub_lib_1.NotificationErrorCode.InvalidInput, 'recipientId and actorId are required');
+        }
+        // Req 9.10: Suppress notifications from quiet-mode connections
+        const isQuiet = await this.isQuietModeConnection(recipientId, actorId);
+        if (isQuiet) {
+            return null;
+        }
+        const category = this.getCategoryForType(type);
+        const isCritical = this.isCriticalNotificationType(type);
+        // Req 56.4: Respect user preferences when creating notifications
+        if (!isCritical) {
+            const prefs = await this.getOrCreateDefaultPreferences(recipientId);
+            // Check if the category is disabled (Req 56.1-56.3)
+            const catSettings = prefs.categorySettings[category];
+            if (catSettings && !catSettings.enabled) {
+                return null;
+            }
+            // Req 56.5-56.6: Check quiet hours
+            if (prefs.quietHours && this.isWithinQuietHours(prefs.quietHours)) {
+                return null;
+            }
+            // Req 56.7-56.8: Check DND
+            if (prefs.dndConfig && this.isDndActive(prefs.dndConfig)) {
+                return null;
+            }
+        }
+        const now = new Date().toISOString();
+        const record = {
+            _id: (0, crypto_1.randomUUID)(),
+            recipientId,
+            type,
+            category,
+            actorId,
+            targetId: options?.targetId,
+            content: options?.content ?? '',
+            clickThroughUrl: options?.clickThroughUrl ?? '',
+            isRead: false,
+            createdAt: now,
+        };
+        await this.notificationsCollection.create(record);
+        return this.recordToNotification(record);
+    }
+    async getNotifications(userId, options) {
+        const limit = this.clampLimit(options?.limit);
+        // Build filter
+        const filter = { recipientId: userId };
+        if (options?.category) {
+            filter.category = options.category;
+        }
+        if (options?.isRead !== undefined) {
+            filter.isRead = options.isRead;
+        }
+        // Query with reverse chronological order
+        let query = this.notificationsCollection.find(filter);
+        if (query.sort) {
+            query = query.sort({ createdAt: -1 });
+        }
+        // Cursor-based pagination: skip past cursor
+        if (options?.cursor && query.skip) {
+            const cursorIndex = parseInt(options.cursor, 10);
+            if (!isNaN(cursorIndex) && cursorIndex > 0) {
+                query = query.skip(cursorIndex);
+            }
+        }
+        // Fetch limit + 1 to determine hasMore
+        if (query.limit) {
+            query = query.limit(limit + 1);
+        }
+        const records = await query.exec();
+        const hasMore = records.length > limit;
+        const items = records
+            .slice(0, limit)
+            .map((r) => this.recordToNotification(r));
+        // Calculate next cursor
+        const currentOffset = options?.cursor
+            ? parseInt(options.cursor, 10) || 0
+            : 0;
+        const nextCursor = hasMore ? String(currentOffset + limit) : undefined;
+        return {
+            items,
+            cursor: nextCursor,
+            hasMore,
+        };
+    }
+    async getUnreadCount(userId) {
+        const filter = {
+            recipientId: userId,
+            isRead: false,
+        };
+        if (this.notificationsCollection.countDocuments) {
+            return this.notificationsCollection.countDocuments(filter).exec();
+        }
+        // Fallback: count via find
+        const records = await this.notificationsCollection.find(filter).exec();
+        return records.length;
+    }
+    async markAsRead(notificationId, userId) {
+        const record = await this.notificationsCollection
+            .findOne({ _id: notificationId })
+            .exec();
+        if (!record) {
+            throw new brighthub_lib_1.NotificationServiceError(brighthub_lib_1.NotificationErrorCode.NotificationNotFound, `Notification ${notificationId} not found`);
+        }
+        if (record.recipientId !== userId) {
+            throw new brighthub_lib_1.NotificationServiceError(brighthub_lib_1.NotificationErrorCode.Unauthorized, "Cannot mark another user's notification as read");
+        }
+        await this.notificationsCollection
+            .updateOne({ _id: notificationId }, { isRead: true })
+            .exec();
+    }
+    async markAllAsRead(userId) {
+        // Find all unread notifications for the user and mark them as read
+        const unread = await this.notificationsCollection
+            .find({
+            recipientId: userId,
+            isRead: false,
+        })
+            .exec();
+        for (const record of unread) {
+            await this.notificationsCollection
+                .updateOne({ _id: record._id }, { isRead: true })
+                .exec();
+        }
+    }
+    async deleteNotification(notificationId, userId) {
+        const record = await this.notificationsCollection
+            .findOne({ _id: notificationId })
+            .exec();
+        if (!record) {
+            throw new brighthub_lib_1.NotificationServiceError(brighthub_lib_1.NotificationErrorCode.NotificationNotFound, `Notification ${notificationId} not found`);
+        }
+        if (record.recipientId !== userId) {
+            throw new brighthub_lib_1.NotificationServiceError(brighthub_lib_1.NotificationErrorCode.Unauthorized, "Cannot delete another user's notification");
+        }
+        await this.notificationsCollection
+            .deleteOne({ _id: notificationId })
+            .exec();
+    }
+    async deleteAllNotifications(userId) {
+        if (this.notificationsCollection.deleteMany) {
+            await this.notificationsCollection
+                .deleteMany({ recipientId: userId })
+                .exec();
+            return;
+        }
+        // Fallback: delete one by one
+        const records = await this.notificationsCollection
+            .find({ recipientId: userId })
+            .exec();
+        for (const record of records) {
+            await this.notificationsCollection
+                .deleteOne({ _id: record._id })
+                .exec();
+        }
+    }
+    // ═══════════════════════════════════════════════════════
+    // Filtering (Req 9.8-9.12)
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Req 9.8: Get notifications filtered by connection list members.
+     * Returns only notifications where the actorId is a member of the given list.
+     */
+    async getNotificationsByList(userId, listId, options) {
+        // Get all member userIds from the list
+        const memberRecords = await this.listMembersCollection
+            .find({ listId })
+            .exec();
+        const memberIds = new Set(memberRecords.map((m) => m.userId));
+        // Get all notifications for the user, then filter by actor membership
+        const allResult = await this.getNotifications(userId, options);
+        const filtered = allResult.items.filter((n) => memberIds.has(n.actorId));
+        return {
+            items: filtered,
+            cursor: allResult.cursor,
+            hasMore: allResult.hasMore,
+        };
+    }
+    /**
+     * Req 9.9: Get notifications filtered by connection category.
+     * Returns only notifications where the actorId is in the given category.
+     */
+    async getNotificationsByConnectionCategory(userId, categoryId, options) {
+        // Get all connections assigned to this category for this user
+        const assignments = await this.categoryAssignmentsCollection
+            .find({
+            ownerId: userId,
+            categoryId,
+        })
+            .exec();
+        const connectionIds = new Set(assignments.map((a) => a.connectionId));
+        // Get all notifications for the user, then filter by actor in category
+        const allResult = await this.getNotifications(userId, options);
+        const filtered = allResult.items.filter((n) => connectionIds.has(n.actorId));
+        return {
+            items: filtered,
+            cursor: allResult.cursor,
+            hasMore: allResult.hasMore,
+        };
+    }
+    /**
+     * Req 9.10: Check if a connection has quiet mode enabled.
+     */
+    async isQuietModeConnection(userId, connectionId) {
+        const metadata = await this.connectionMetadataCollection
+            .findOne({
+            userId,
+            connectionId,
+        })
+            .exec();
+        return metadata?.isQuiet === true;
+    }
+    /**
+     * Req 9.12: Create a reconnect reminder for a 30-day inactive connection.
+     * Checks that the connection hasn't interacted in RECONNECT_REMINDER_DAYS days,
+     * then creates a notification with type ReconnectReminder and category Connections.
+     */
+    async createReconnectReminder(userId, connectionId) {
+        // Look up the interaction record
+        const interaction = await this.connectionInteractionsCollection
+            .findOne({
+            userId,
+            connectionId,
+        })
+            .exec();
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - brighthub_lib_1.RECONNECT_REMINDER_DAYS);
+        // If there's a recent interaction, don't create a reminder
+        if (interaction?.lastInteractionAt) {
+            const lastInteraction = new Date(interaction.lastInteractionAt);
+            if (lastInteraction > cutoffDate) {
+                throw new brighthub_lib_1.NotificationServiceError(brighthub_lib_1.NotificationErrorCode.InvalidInput, `Connection ${connectionId} has interacted within the last ${brighthub_lib_1.RECONNECT_REMINDER_DAYS} days`);
+            }
+        }
+        // Create the reconnect reminder notification directly (bypass quiet mode check
+        // since this is a system-initiated reminder, not an actor-initiated notification)
+        const now = new Date().toISOString();
+        const record = {
+            _id: (0, crypto_1.randomUUID)(),
+            recipientId: userId,
+            type: brighthub_lib_1.NotificationType.ReconnectReminder,
+            category: brighthub_lib_1.NotificationCategory.Connections,
+            actorId: connectionId,
+            content: `You haven't interacted with this connection in ${brighthub_lib_1.RECONNECT_REMINDER_DAYS} days. Consider reconnecting!`,
+            clickThroughUrl: `/users/${connectionId}`,
+            isRead: false,
+            createdAt: now,
+        };
+        await this.notificationsCollection.create(record);
+        return this.recordToNotification(record);
+    }
+    // ═══════════════════════════════════════════════════════
+    // Preferences (Req 56.1-56.12)
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Get notification preferences for a user.
+     * Returns existing preferences or creates defaults if none exist.
+     * Req 56.11: Store preferences in user profile and sync across devices.
+     */
+    async getPreferences(userId) {
+        return this.getOrCreateDefaultPreferences(userId);
+    }
+    /**
+     * Update notification preferences for a user.
+     * Merges partial updates into existing preferences.
+     * Req 56.1-56.3: Per-category enable/disable and per-channel settings.
+     * Req 56.10: Sound preferences.
+     * Req 56.12: Preferences update reflected immediately.
+     */
+    async updatePreferences(userId, preferences) {
+        const existing = await this.getOrCreateDefaultPreferences(userId);
+        // Merge category settings
+        if (preferences.categorySettings) {
+            for (const cat of Object.values(brighthub_lib_1.NotificationCategory)) {
+                if (preferences.categorySettings[cat]) {
+                    existing.categorySettings[cat] = {
+                        ...existing.categorySettings[cat],
+                        ...preferences.categorySettings[cat],
+                        channels: {
+                            ...existing.categorySettings[cat].channels,
+                            ...(preferences.categorySettings[cat].channels ?? {}),
+                        },
+                    };
+                }
+            }
+        }
+        // Merge channel settings
+        if (preferences.channelSettings) {
+            existing.channelSettings = {
+                ...existing.channelSettings,
+                ...preferences.channelSettings,
+            };
+        }
+        // Merge optional fields
+        if (preferences.quietHours !== undefined) {
+            existing.quietHours = preferences.quietHours;
+        }
+        if (preferences.dndConfig !== undefined) {
+            existing.dndConfig = preferences.dndConfig;
+        }
+        if (preferences.soundEnabled !== undefined) {
+            existing.soundEnabled = preferences.soundEnabled;
+        }
+        // Save to database
+        const now = new Date().toISOString();
+        await this.preferencesCollection
+            .updateOne({ userId }, {
+            categorySettings: existing.categorySettings,
+            channelSettings: existing.channelSettings,
+            quietHours: existing.quietHours,
+            dndConfig: existing.dndConfig,
+            soundEnabled: existing.soundEnabled,
+            updatedAt: now,
+        })
+            .exec();
+        return existing;
+    }
+    /**
+     * Set quiet hours configuration.
+     * Req 56.5: Suppress in-app notifications during quiet hours.
+     * Req 56.6: Start/end times with timezone support.
+     */
+    async setQuietHours(userId, config) {
+        // Validate HH:mm format
+        const timeRegex = /^\d{2}:\d{2}$/;
+        if (!timeRegex.test(config.startTime) || !timeRegex.test(config.endTime)) {
+            throw new brighthub_lib_1.NotificationServiceError(brighthub_lib_1.NotificationErrorCode.InvalidQuietHoursConfig, 'startTime and endTime must be in HH:mm format');
+        }
+        // Validate timezone is non-empty
+        if (!config.timezone || config.timezone.trim().length === 0) {
+            throw new brighthub_lib_1.NotificationServiceError(brighthub_lib_1.NotificationErrorCode.InvalidQuietHoursConfig, 'timezone is required');
+        }
+        // Get or create preferences, then update quiet hours
+        await this.getOrCreateDefaultPreferences(userId);
+        const now = new Date().toISOString();
+        await this.preferencesCollection
+            .updateOne({ userId }, {
+            quietHours: config,
+            updatedAt: now,
+        })
+            .exec();
+    }
+    /**
+     * Set Do Not Disturb configuration.
+     * Req 56.7: DND suppresses all non-critical notifications.
+     * Req 56.8: Duration options (1h, 8h, 24h, until manually disabled).
+     * Req 56.9: Critical system notifications still delivered during DND.
+     */
+    async setDoNotDisturb(userId, config) {
+        // Calculate expiresAt from duration if provided
+        const resolvedConfig = { ...config };
+        if (config.enabled && config.duration && !config.expiresAt) {
+            const now = new Date();
+            const durationMs = this.parseDurationToMs(config.duration);
+            if (durationMs > 0) {
+                resolvedConfig.expiresAt = new Date(now.getTime() + durationMs).toISOString();
+            }
+            // Permanent duration: no expiresAt
+        }
+        // Get or create preferences, then update DND config
+        await this.getOrCreateDefaultPreferences(userId);
+        const now = new Date().toISOString();
+        await this.preferencesCollection
+            .updateOne({ userId }, {
+            dndConfig: resolvedConfig,
+            updatedAt: now,
+        })
+            .exec();
+    }
+    /**
+     * Convert a MuteDuration to milliseconds.
+     * Returns 0 for Permanent (no expiration).
+     */
+    parseDurationToMs(duration) {
+        switch (duration) {
+            case brighthub_lib_1.MuteDuration.OneHour:
+                return 60 * 60 * 1000;
+            case brighthub_lib_1.MuteDuration.EightHours:
+                return 8 * 60 * 60 * 1000;
+            case brighthub_lib_1.MuteDuration.TwentyFourHours:
+                return 24 * 60 * 60 * 1000;
+            case brighthub_lib_1.MuteDuration.SevenDays:
+                return 7 * 24 * 60 * 60 * 1000;
+            case brighthub_lib_1.MuteDuration.ThirtyDays:
+                return 30 * 24 * 60 * 60 * 1000;
+            case brighthub_lib_1.MuteDuration.Permanent:
+                return 0;
+            default:
+                return 0;
+        }
+    }
+    // ═══════════════════════════════════════════════════════
+    // Grouping (Req 55.6-55.9)
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Group notifications by type and target within the grouping window (1 hour).
+     *
+     * Req 55.6: Same action on same content within 1 hour → single grouped notification
+     * Req 55.7: Grouped notification displays count and list of actors
+     * Req 55.8: Individual actors with timestamps available via notificationIds
+     * Req 55.9: Supports ungrouping via skipGrouping flag (preference-driven)
+     *
+     * @param notifications - Array of notifications to group
+     * @param skipGrouping  - When true, each notification becomes its own group (Req 55.9)
+     * @returns Array of notification groups
+     */
+    async groupNotifications(notifications, skipGrouping) {
+        if (notifications.length === 0) {
+            return [];
+        }
+        // Req 55.9: If ungrouping is preferred, return each notification as its own group
+        if (skipGrouping) {
+            return notifications.map((n) => ({
+                _id: (0, crypto_1.randomUUID)(),
+                groupKey: `${n.type}:${n.targetId ?? n._id}`,
+                notificationIds: [n._id],
+                actorIds: [n.actorId],
+                count: 1,
+                latestAt: n.createdAt,
+            }));
+        }
+        // Sort notifications by createdAt ascending so we process oldest first
+        const sorted = [...notifications].sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+        // Build groups keyed by type:targetId.
+        // Within each key, we may have multiple time-window clusters.
+        const groupClusters = new Map();
+        for (const notification of sorted) {
+            const groupKey = `${notification.type}:${notification.targetId ?? notification._id}`;
+            const createdAtMs = new Date(notification.createdAt).getTime();
+            if (!groupClusters.has(groupKey)) {
+                groupClusters.set(groupKey, []);
+            }
+            const clusters = groupClusters.get(groupKey);
+            // Try to find an existing cluster where this notification fits
+            // (within NOTIFICATION_GROUPING_WINDOW_MS of the cluster's earliest notification)
+            let addedToCluster = false;
+            for (const cluster of clusters) {
+                if (createdAtMs - cluster.earliestAt <
+                    brighthub_lib_1.NOTIFICATION_GROUPING_WINDOW_MS) {
+                    cluster.notificationIds.push(notification._id);
+                    cluster.actorIds.add(notification.actorId);
+                    if (createdAtMs > cluster.latestAt) {
+                        cluster.latestAt = createdAtMs;
+                    }
+                    addedToCluster = true;
+                    break;
+                }
+            }
+            // No matching cluster found — start a new one
+            if (!addedToCluster) {
+                clusters.push({
+                    notificationIds: [notification._id],
+                    actorIds: new Set([notification.actorId]),
+                    earliestAt: createdAtMs,
+                    latestAt: createdAtMs,
+                });
+            }
+        }
+        // Convert clusters to IBaseNotificationGroup<string>
+        const groups = [];
+        for (const [groupKey, clusters] of groupClusters) {
+            for (const cluster of clusters) {
+                groups.push({
+                    _id: (0, crypto_1.randomUUID)(),
+                    groupKey,
+                    notificationIds: cluster.notificationIds,
+                    actorIds: Array.from(cluster.actorIds),
+                    count: cluster.notificationIds.length,
+                    latestAt: new Date(cluster.latestAt).toISOString(),
+                });
+            }
+        }
+        // Sort groups by latestAt descending (most recent first)
+        groups.sort((a, b) => new Date(b.latestAt).getTime() - new Date(a.latestAt).getTime());
+        return groups;
+    }
+    // ═══════════════════════════════════════════════════════
+    // Real-time (Req 52.4, 52.5) — Task 20
+    // ═══════════════════════════════════════════════════════
+    wsHandler = null;
+    /**
+     * Late-bind the WebSocket handler for real-time notification delivery.
+     * Called after both NotificationService and BrightHubWebSocketHandler are created.
+     */
+    setWebSocketHandler(handler) {
+        this.wsHandler = handler;
+    }
+    subscribeToNotifications(_userId, _callback) {
+        // Real-time subscriptions are handled by BrightHubWebSocketHandler
+        // via room-based pub/sub on ClientWebSocketServer.
+        // This method is kept for interface compatibility.
+        return () => {
+            /* unsubscribe is handled by WebSocket disconnect */
+        };
+    }
+    async broadcastNotification(notification) {
+        if (this.wsHandler) {
+            this.wsHandler.broadcastNotification(notification);
+            // Also send updated unread count
+            const count = await this.getUnreadCount(notification.recipientId);
+            this.wsHandler.broadcastNotificationCount(notification.recipientId, count);
+        }
+    }
+}
+exports.NotificationService = NotificationService;
+// ═══════════════════════════════════════════════════════
+// Factory function
+// ═══════════════════════════════════════════════════════
+/**
+ * Create a new NotificationService instance
+ * @param application Application with database collections
+ * @returns NotificationService instance
+ */
+function createNotificationService(application) {
+    return new NotificationService(application);
+}
+//# sourceMappingURL=notificationService.js.map