@brightchain/brightchain-api-lib 0.23.25 → 0.24.1

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

@@ -0,0 +1,947 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagingService = void 0;
+exports.createMessagingService = createMessagingService;
+const brighthub_lib_1 = require("@brightchain/brighthub-lib");
+const crypto_1 = require("crypto");
+const textFormatter_1 = require("./textFormatter");
+/** Default pagination limit */
+const DEFAULT_PAGE_LIMIT = 20;
+/** Maximum pagination limit */
+const MAX_PAGE_LIMIT = 100;
+// ═══════════════════════════════════════════════════════
+// MessagingService Implementation
+// ═══════════════════════════════════════════════════════
+/**
+ * Messaging_Service implementation
+ * Handles conversations, messages, reactions, read receipts, and message requests
+ * @see Requirements: 39-43
+ */
+class MessagingService {
+    conversationsCollection;
+    messagesCollection;
+    messageRequestsCollection;
+    messageReactionsCollection;
+    readReceiptsCollection;
+    pinnedConversationsCollection;
+    archivedConversationsCollection;
+    mutedConversationsCollection;
+    participantsCollection;
+    followsCollection;
+    blocksCollection;
+    deletedConversationsCollection;
+    textFormatter = (0, textFormatter_1.getTextFormatter)();
+    constructor(application) {
+        this.conversationsCollection = application.getModel('brighthub_conversations');
+        this.messagesCollection =
+            application.getModel('brighthub_messages');
+        this.messageRequestsCollection = application.getModel('brighthub_message_requests');
+        this.messageReactionsCollection =
+            application.getModel('brighthub_message_reactions');
+        this.readReceiptsCollection = application.getModel('brighthub_read_receipts');
+        this.pinnedConversationsCollection =
+            application.getModel('brighthub_pinned_conversations');
+        this.archivedConversationsCollection =
+            application.getModel('brighthub_archived_conversations');
+        this.mutedConversationsCollection =
+            application.getModel('brighthub_muted_conversations');
+        this.participantsCollection =
+            application.getModel('brighthub_conversation_participants');
+        this.followsCollection =
+            application.getModel('brighthub_follows');
+        this.blocksCollection =
+            application.getModel('brighthub_blocks');
+        this.deletedConversationsCollection =
+            application.getModel('brighthub_deleted_conversations');
+    }
+    // ═══════════════════════════════════════════════════════
+    // Private helpers
+    // ═══════════════════════════════════════════════════════
+    clampLimit(limit) {
+        const l = limit ?? DEFAULT_PAGE_LIMIT;
+        return Math.min(Math.max(1, l), MAX_PAGE_LIMIT);
+    }
+    validateMessageContent(content) {
+        if (!content || content.trim().length === 0) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.EmptyContent, 'Message content cannot be empty');
+        }
+        if (this.textFormatter.getCharacterCount(content) > brighthub_lib_1.MAX_MESSAGE_LENGTH) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.ContentTooLong, `Message content exceeds maximum of ${brighthub_lib_1.MAX_MESSAGE_LENGTH} characters`);
+        }
+    }
+    validateAttachments(attachments) {
+        if (!attachments || attachments.length === 0)
+            return;
+        if (attachments.length > brighthub_lib_1.MAX_MESSAGE_ATTACHMENTS) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.TooManyAttachments, `Maximum ${brighthub_lib_1.MAX_MESSAGE_ATTACHMENTS} attachments allowed per message`);
+        }
+        const totalSize = attachments.reduce((sum, a) => sum + (a.size ?? 0), 0);
+        if (totalSize > brighthub_lib_1.MAX_MESSAGE_ATTACHMENT_SIZE) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.AttachmentSizeTooLarge, `Total attachment size exceeds ${brighthub_lib_1.MAX_MESSAGE_ATTACHMENT_SIZE / (1024 * 1024)}MB limit`);
+        }
+        for (const att of attachments) {
+            if (!brighthub_lib_1.ALLOWED_MESSAGE_MEDIA_TYPES.includes(att.mimeType)) {
+                throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.InvalidMediaFormat, `Invalid media format: ${att.mimeType}. Allowed: ${brighthub_lib_1.ALLOWED_MESSAGE_MEDIA_TYPES.join(', ')}`);
+            }
+        }
+    }
+    recordToConversation(record) {
+        return {
+            _id: record._id,
+            type: record.type,
+            participantIds: record.participantIds,
+            name: record.name,
+            avatarUrl: record.avatarUrl,
+            lastMessageAt: record.lastMessageAt,
+            lastMessagePreview: record.lastMessagePreview,
+            createdAt: record.createdAt,
+            updatedAt: record.updatedAt,
+        };
+    }
+    recordToGroupConversation(record) {
+        return {
+            ...this.recordToConversation(record),
+            type: brighthub_lib_1.ConversationType.Group,
+            adminIds: record.adminIds ?? [],
+            creatorId: record.creatorId ?? '',
+        };
+    }
+    recordToMessage(record) {
+        return {
+            _id: record._id,
+            conversationId: record.conversationId,
+            senderId: record.senderId,
+            content: record.content,
+            formattedContent: record.formattedContent,
+            attachments: record.attachments,
+            replyToMessageId: record.replyToMessageId,
+            forwardedFromId: record.forwardedFromId,
+            isEdited: record.isEdited,
+            editedAt: record.editedAt,
+            isDeleted: record.isDeleted,
+            createdAt: record.createdAt,
+        };
+    }
+    async assertParticipant(conversationId, userId) {
+        const conv = await this.conversationsCollection
+            .findOne({ _id: conversationId })
+            .exec();
+        if (!conv) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.ConversationNotFound, 'Conversation not found');
+        }
+        // Check if user deleted this conversation from their view
+        const deleted = await this.deletedConversationsCollection
+            .findOne({
+            userId,
+            conversationId,
+        })
+            .exec();
+        if (deleted) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.ConversationNotFound, 'Conversation not found');
+        }
+        if (!conv.participantIds.includes(userId)) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.NotParticipant, 'User is not a participant in this conversation');
+        }
+        return conv;
+    }
+    async assertGroupAdmin(conv, userId) {
+        if (conv.type !== brighthub_lib_1.ConversationType.Group) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.NotAdmin, 'Not a group conversation');
+        }
+        if (!conv.adminIds?.includes(userId)) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.NotAdmin, 'User is not an admin of this group');
+        }
+    }
+    async isBlocked(userId, otherUserId) {
+        const block1 = await this.blocksCollection
+            .findOne({
+            blockerId: userId,
+            blockedId: otherUserId,
+        })
+            .exec();
+        if (block1)
+            return true;
+        const block2 = await this.blocksCollection
+            .findOne({
+            blockerId: otherUserId,
+            blockedId: userId,
+        })
+            .exec();
+        return !!block2;
+    }
+    // ═══════════════════════════════════════════════════════
+    // Conversation Management (Req 39.1, 39.2, 43.1-43.11)
+    // ═══════════════════════════════════════════════════════
+    async createDirectConversation(userId, otherUserId) {
+        if (await this.isBlocked(userId, otherUserId)) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.UserBlocked, 'Cannot create conversation with blocked user');
+        }
+        // Check for existing direct conversation between these two users
+        const allConvs = await this.conversationsCollection
+            .find({ type: brighthub_lib_1.ConversationType.Direct })
+            .exec();
+        const existing = allConvs.find((c) => c.participantIds.length === 2 &&
+            c.participantIds.includes(userId) &&
+            c.participantIds.includes(otherUserId));
+        if (existing) {
+            // If user previously deleted it, remove the deletion record
+            if (this.deletedConversationsCollection.deleteOne) {
+                await this.deletedConversationsCollection
+                    .deleteOne({
+                    userId,
+                    conversationId: existing._id,
+                })
+                    .exec();
+            }
+            return this.recordToConversation(existing);
+        }
+        const now = new Date().toISOString();
+        const record = {
+            _id: (0, crypto_1.randomUUID)(),
+            type: brighthub_lib_1.ConversationType.Direct,
+            participantIds: [userId, otherUserId],
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.conversationsCollection.create(record);
+        return this.recordToConversation(record);
+    }
+    async createGroupConversation(creatorId, participantIds, options) {
+        if (!options.name || options.name.trim().length === 0) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.InvalidGroupName, 'Group name cannot be empty');
+        }
+        const allParticipants = [...new Set([creatorId, ...participantIds])];
+        if (allParticipants.length > brighthub_lib_1.MAX_GROUP_PARTICIPANTS) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.GroupParticipantLimitExceeded, `Group cannot exceed ${brighthub_lib_1.MAX_GROUP_PARTICIPANTS} participants`);
+        }
+        const now = new Date().toISOString();
+        const record = {
+            _id: (0, crypto_1.randomUUID)(),
+            type: brighthub_lib_1.ConversationType.Group,
+            participantIds: allParticipants,
+            name: options.name.trim(),
+            avatarUrl: options.avatarUrl,
+            adminIds: [creatorId],
+            creatorId,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.conversationsCollection.create(record);
+        // Create participant records
+        for (const pid of allParticipants) {
+            await this.participantsCollection.create({
+                _id: (0, crypto_1.randomUUID)(),
+                conversationId: record._id,
+                userId: pid,
+                role: pid === creatorId
+                    ? brighthub_lib_1.GroupParticipantRole.Admin
+                    : brighthub_lib_1.GroupParticipantRole.Participant,
+                notificationsEnabled: true,
+                joinedAt: now,
+            });
+        }
+        return this.recordToGroupConversation(record);
+    }
+    async getConversation(conversationId, userId) {
+        const conv = await this.assertParticipant(conversationId, userId);
+        if (conv.type === brighthub_lib_1.ConversationType.Group) {
+            return this.recordToGroupConversation(conv);
+        }
+        return this.recordToConversation(conv);
+    }
+    async getConversations(userId, options) {
+        const limit = this.clampLimit(options?.limit);
+        // Get all conversations where user is a participant
+        const allConvs = await this.conversationsCollection
+            .find({})
+            .exec();
+        // Get deleted conversation IDs for this user
+        const deletedRecords = await this.deletedConversationsCollection
+            .find({ userId })
+            .exec();
+        const deletedIds = new Set(deletedRecords.map((d) => d.conversationId));
+        let filtered = allConvs.filter((c) => c.participantIds.includes(userId) && !deletedIds.has(c._id));
+        // Apply cursor (ISO timestamp)
+        if (options?.cursor) {
+            filtered = filtered.filter((c) => (c.lastMessageAt ?? c.createdAt) < options.cursor);
+        }
+        // Sort by most recent activity
+        filtered.sort((a, b) => {
+            const aTime = a.lastMessageAt ?? a.createdAt;
+            const bTime = b.lastMessageAt ?? b.createdAt;
+            return bTime.localeCompare(aTime);
+        });
+        const items = filtered
+            .slice(0, limit)
+            .map((c) => c.type === brighthub_lib_1.ConversationType.Group
+            ? this.recordToGroupConversation(c)
+            : this.recordToConversation(c));
+        const hasMore = filtered.length > limit;
+        const lastItem = items[items.length - 1];
+        const cursor = hasMore && lastItem
+            ? (lastItem.lastMessageAt ?? lastItem.createdAt)
+            : undefined;
+        return { items, cursor, hasMore };
+    }
+    async deleteConversation(conversationId, userId) {
+        await this.assertParticipant(conversationId, userId);
+        // Soft-delete: record that this user deleted the conversation
+        const existing = await this.deletedConversationsCollection
+            .findOne({ userId, conversationId })
+            .exec();
+        if (!existing) {
+            await this.deletedConversationsCollection.create({
+                _id: (0, crypto_1.randomUUID)(),
+                userId,
+                conversationId,
+                deletedAt: new Date().toISOString(),
+            });
+        }
+    }
+    // ═══════════════════════════════════════════════════════
+    // Message CRUD (Req 39.1-39.4, 41.1-41.9)
+    // ═══════════════════════════════════════════════════════
+    async sendMessage(conversationId, senderId, content, options) {
+        this.validateMessageContent(content);
+        this.validateAttachments(options?.attachments);
+        await this.assertParticipant(conversationId, senderId);
+        const formatted = this.textFormatter.format(content);
+        const now = new Date().toISOString();
+        // Validate replyToMessageId if provided
+        if (options?.replyToMessageId) {
+            const replyTarget = await this.messagesCollection
+                .findOne({ _id: options.replyToMessageId })
+                .exec();
+            if (!replyTarget || replyTarget.conversationId !== conversationId) {
+                throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.MessageNotFound, 'Reply target message not found in this conversation');
+            }
+        }
+        // Validate forwardedFromId if provided
+        if (options?.forwardedFromId) {
+            const forwardSource = await this.messagesCollection
+                .findOne({ _id: options.forwardedFromId })
+                .exec();
+            if (!forwardSource) {
+                throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.MessageNotFound, 'Forwarded message not found');
+            }
+        }
+        const record = {
+            _id: (0, crypto_1.randomUUID)(),
+            conversationId,
+            senderId,
+            content,
+            formattedContent: formatted.formatted,
+            attachments: (options?.attachments ?? []),
+            replyToMessageId: options?.replyToMessageId,
+            forwardedFromId: options?.forwardedFromId,
+            isEdited: false,
+            isDeleted: false,
+            createdAt: now,
+        };
+        await this.messagesCollection.create(record);
+        // Update conversation's last message info
+        const preview = content.length > 100 ? content.substring(0, 97) + '...' : content;
+        await this.conversationsCollection
+            .updateOne({ _id: conversationId }, {
+            lastMessageAt: now,
+            lastMessagePreview: preview,
+            updatedAt: now,
+        })
+            .exec();
+        return this.recordToMessage(record);
+    }
+    async editMessage(messageId, userId, newContent) {
+        this.validateMessageContent(newContent);
+        const message = await this.messagesCollection
+            .findOne({ _id: messageId })
+            .exec();
+        if (!message) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.MessageNotFound, 'Message not found');
+        }
+        if (message.senderId !== userId) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.Unauthorized, 'Only the sender can edit a message');
+        }
+        if (message.isDeleted) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.MessageAlreadyDeleted, 'Cannot edit a deleted message');
+        }
+        const createdAt = new Date(message.createdAt).getTime();
+        if (Date.now() - createdAt > brighthub_lib_1.MESSAGE_EDIT_WINDOW_MS) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.EditWindowExpired, 'Edit window has expired (15 minutes)');
+        }
+        const formatted = this.textFormatter.format(newContent);
+        const now = new Date().toISOString();
+        await this.messagesCollection
+            .updateOne({ _id: messageId }, {
+            content: newContent,
+            formattedContent: formatted.formatted,
+            isEdited: true,
+            editedAt: now,
+        })
+            .exec();
+        return this.recordToMessage({
+            ...message,
+            content: newContent,
+            formattedContent: formatted.formatted,
+            isEdited: true,
+            editedAt: now,
+        });
+    }
+    async deleteMessage(messageId, userId) {
+        const message = await this.messagesCollection
+            .findOne({ _id: messageId })
+            .exec();
+        if (!message) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.MessageNotFound, 'Message not found');
+        }
+        if (message.senderId !== userId) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.Unauthorized, 'Only the sender can delete a message');
+        }
+        if (message.isDeleted) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.MessageAlreadyDeleted, 'Message is already deleted');
+        }
+        // Soft-delete: replace content with placeholder
+        await this.messagesCollection
+            .updateOne({ _id: messageId }, {
+            content: '',
+            formattedContent: '<p><em>This message was deleted</em></p>',
+            isDeleted: true,
+            attachments: [],
+        })
+            .exec();
+    }
+    async getMessages(conversationId, userId, options) {
+        await this.assertParticipant(conversationId, userId);
+        const limit = this.clampLimit(options?.limit);
+        let messages = await this.messagesCollection
+            .find({ conversationId })
+            .exec();
+        // Apply cursor
+        if (options?.cursor) {
+            messages = messages.filter((m) => m.createdAt < options.cursor);
+        }
+        // Sort by newest first
+        messages.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        const page = messages.slice(0, limit);
+        const hasMore = messages.length > limit;
+        const lastItem = page[page.length - 1];
+        return {
+            items: page.map((m) => this.recordToMessage(m)),
+            cursor: hasMore && lastItem ? lastItem.createdAt : undefined,
+            hasMore,
+        };
+    }
+    // ═══════════════════════════════════════════════════════
+    // Reactions (Req 39.8-39.10)
+    // ═══════════════════════════════════════════════════════
+    async addReaction(messageId, userId, emoji) {
+        const message = await this.messagesCollection
+            .findOne({ _id: messageId })
+            .exec();
+        if (!message || message.isDeleted) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.MessageNotFound, 'Message not found');
+        }
+        // Check user is participant
+        await this.assertParticipant(message.conversationId, userId);
+        // Check for duplicate reaction (same user, same emoji)
+        const existing = await this.messageReactionsCollection
+            .find({ messageId })
+            .exec();
+        const duplicate = existing.find((r) => r.userId === userId && r.emoji === emoji);
+        if (duplicate) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.ReactionAlreadyExists, 'You already reacted with this emoji');
+        }
+        // Check unique emoji limit per message
+        const uniqueEmojis = new Set(existing.map((r) => r.emoji));
+        if (!uniqueEmojis.has(emoji) &&
+            uniqueEmojis.size >= brighthub_lib_1.MAX_REACTIONS_PER_MESSAGE) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.ReactionLimitExceeded, `Maximum ${brighthub_lib_1.MAX_REACTIONS_PER_MESSAGE} unique emoji reactions per message`);
+        }
+        const record = {
+            _id: (0, crypto_1.randomUUID)(),
+            messageId,
+            userId,
+            emoji,
+            createdAt: new Date().toISOString(),
+        };
+        await this.messageReactionsCollection.create(record);
+        return {
+            _id: record._id,
+            messageId: record.messageId,
+            userId: record.userId,
+            emoji: record.emoji,
+            createdAt: record.createdAt,
+        };
+    }
+    async removeReaction(messageId, userId, emoji) {
+        const reactions = await this.messageReactionsCollection
+            .find({ messageId })
+            .exec();
+        const reaction = reactions.find((r) => r.userId === userId && r.emoji === emoji);
+        if (!reaction) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.ReactionNotFound, 'Reaction not found');
+        }
+        await this.messageReactionsCollection
+            .deleteOne({ _id: reaction._id })
+            .exec();
+    }
+    // ═══════════════════════════════════════════════════════
+    // Read Receipts & Typing (Req 39.5-39.7)
+    // ═══════════════════════════════════════════════════════
+    async markAsRead(conversationId, userId, messageId) {
+        await this.assertParticipant(conversationId, userId);
+        const now = new Date().toISOString();
+        // Upsert read receipt
+        const existing = await this.readReceiptsCollection
+            .find({ conversationId })
+            .exec();
+        const userReceipt = existing.find((r) => r.userId === userId);
+        if (userReceipt) {
+            await this.readReceiptsCollection
+                .updateOne({ _id: userReceipt._id }, {
+                lastReadAt: now,
+                lastReadMessageId: messageId,
+            })
+                .exec();
+            return {
+                conversationId,
+                userId,
+                lastReadAt: now,
+                lastReadMessageId: messageId,
+            };
+        }
+        const record = {
+            _id: (0, crypto_1.randomUUID)(),
+            conversationId,
+            userId,
+            lastReadAt: now,
+            lastReadMessageId: messageId,
+        };
+        await this.readReceiptsCollection.create(record);
+        return {
+            conversationId: record.conversationId,
+            userId: record.userId,
+            lastReadAt: record.lastReadAt,
+            lastReadMessageId: record.lastReadMessageId,
+        };
+    }
+    async sendTypingIndicator(conversationId, userId) {
+        await this.assertParticipant(conversationId, userId);
+        const expiresAt = new Date(Date.now() + brighthub_lib_1.TYPING_INDICATOR_TIMEOUT_MS).toISOString();
+        return { expiresAt };
+    }
+    // ═══════════════════════════════════════════════════════
+    // Message Requests & Privacy (Req 42.1-42.12)
+    // ═══════════════════════════════════════════════════════
+    async createMessageRequest(senderId, recipientId, messagePreview) {
+        if (await this.isBlocked(senderId, recipientId)) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.UserBlocked, 'Cannot send message request to this user');
+        }
+        // Check for existing pending request
+        const allRequests = await this.messageRequestsCollection
+            .find({ senderId })
+            .exec();
+        const existing = allRequests.find((r) => r.recipientId === recipientId &&
+            r.status === brighthub_lib_1.MessageRequestStatus.Pending);
+        if (existing) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.MessageRequestAlreadyExists, 'A pending message request already exists for this user');
+        }
+        const preview = messagePreview.length > 100
+            ? messagePreview.substring(0, 97) + '...'
+            : messagePreview;
+        const record = {
+            _id: (0, crypto_1.randomUUID)(),
+            senderId,
+            recipientId,
+            messagePreview: preview,
+            status: brighthub_lib_1.MessageRequestStatus.Pending,
+            createdAt: new Date().toISOString(),
+        };
+        await this.messageRequestsCollection.create(record);
+        return {
+            _id: record._id,
+            senderId: record.senderId,
+            recipientId: record.recipientId,
+            messagePreview: record.messagePreview,
+            status: record.status,
+            createdAt: record.createdAt,
+        };
+    }
+    async acceptMessageRequest(requestId, recipientId) {
+        const request = await this.messageRequestsCollection
+            .findOne({ _id: requestId })
+            .exec();
+        if (!request || request.recipientId !== recipientId) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.MessageRequestNotFound, 'Message request not found');
+        }
+        // Update request status
+        await this.messageRequestsCollection
+            .updateOne({ _id: requestId }, {
+            status: brighthub_lib_1.MessageRequestStatus.Accepted,
+        })
+            .exec();
+        // Create a direct conversation
+        return this.createDirectConversation(recipientId, request.senderId);
+    }
+    async declineMessageRequest(requestId, recipientId) {
+        const request = await this.messageRequestsCollection
+            .findOne({ _id: requestId })
+            .exec();
+        if (!request || request.recipientId !== recipientId) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.MessageRequestNotFound, 'Message request not found');
+        }
+        await this.messageRequestsCollection
+            .updateOne({ _id: requestId }, {
+            status: brighthub_lib_1.MessageRequestStatus.Declined,
+        })
+            .exec();
+    }
+    async canMessageDirectly(senderId, recipientId) {
+        if (await this.isBlocked(senderId, recipientId)) {
+            return false;
+        }
+        // Check mutual follow
+        const senderFollows = await this.followsCollection
+            .findOne({
+            followerId: senderId,
+            followedId: recipientId,
+        })
+            .exec();
+        const recipientFollows = await this.followsCollection
+            .findOne({
+            followerId: recipientId,
+            followedId: senderId,
+        })
+            .exec();
+        return !!(senderFollows && recipientFollows);
+    }
+    // ═══════════════════════════════════════════════════════
+    // Conversation Management Features (Req 43.3-43.11)
+    // ═══════════════════════════════════════════════════════
+    async pinConversation(conversationId, userId) {
+        await this.assertParticipant(conversationId, userId);
+        const existing = await this.pinnedConversationsCollection
+            .findOne({ userId, conversationId })
+            .exec();
+        if (existing) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.AlreadyPinned, 'Conversation is already pinned');
+        }
+        // Check pin limit
+        const pinned = await this.pinnedConversationsCollection
+            .find({ userId })
+            .exec();
+        if (pinned.length >= brighthub_lib_1.MAX_PINNED_CONVERSATIONS) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.PinLimitExceeded, `Maximum ${brighthub_lib_1.MAX_PINNED_CONVERSATIONS} pinned conversations allowed`);
+        }
+        await this.pinnedConversationsCollection.create({
+            _id: (0, crypto_1.randomUUID)(),
+            userId,
+            conversationId,
+            pinnedAt: new Date().toISOString(),
+        });
+    }
+    async unpinConversation(conversationId, userId) {
+        const existing = await this.pinnedConversationsCollection
+            .findOne({ userId, conversationId })
+            .exec();
+        if (!existing) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.NotPinned, 'Conversation is not pinned');
+        }
+        await this.pinnedConversationsCollection
+            .deleteOne({ _id: existing._id })
+            .exec();
+    }
+    async archiveConversation(conversationId, userId) {
+        await this.assertParticipant(conversationId, userId);
+        const existing = await this.archivedConversationsCollection
+            .findOne({
+            userId,
+            conversationId,
+        })
+            .exec();
+        if (existing) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.AlreadyArchived, 'Conversation is already archived');
+        }
+        await this.archivedConversationsCollection.create({
+            _id: (0, crypto_1.randomUUID)(),
+            userId,
+            conversationId,
+            archivedAt: new Date().toISOString(),
+        });
+    }
+    async unarchiveConversation(conversationId, userId) {
+        const existing = await this.archivedConversationsCollection
+            .findOne({
+            userId,
+            conversationId,
+        })
+            .exec();
+        if (!existing) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.NotArchived, 'Conversation is not archived');
+        }
+        await this.archivedConversationsCollection
+            .deleteOne({ _id: existing._id })
+            .exec();
+    }
+    async muteConversation(conversationId, userId, expiresAt) {
+        await this.assertParticipant(conversationId, userId);
+        const existing = await this.mutedConversationsCollection
+            .findOne({ userId, conversationId })
+            .exec();
+        if (existing) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.AlreadyMuted, 'Conversation is already muted');
+        }
+        await this.mutedConversationsCollection.create({
+            _id: (0, crypto_1.randomUUID)(),
+            userId,
+            conversationId,
+            expiresAt,
+            mutedAt: new Date().toISOString(),
+        });
+    }
+    async unmuteConversation(conversationId, userId) {
+        const existing = await this.mutedConversationsCollection
+            .findOne({ userId, conversationId })
+            .exec();
+        if (!existing) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.NotMuted, 'Conversation is not muted');
+        }
+        await this.mutedConversationsCollection
+            .deleteOne({ _id: existing._id })
+            .exec();
+    }
+    async searchMessages(userId, query, options) {
+        const limit = this.clampLimit(options?.limit);
+        const lowerQuery = query.toLowerCase();
+        // Get user's conversations
+        const allConvs = await this.conversationsCollection
+            .find({})
+            .exec();
+        const userConvIds = allConvs
+            .filter((c) => c.participantIds.includes(userId))
+            .map((c) => c._id);
+        // Search messages in those conversations
+        const allMessages = await this.messagesCollection
+            .find({})
+            .exec();
+        let matched = allMessages.filter((m) => userConvIds.includes(m.conversationId) &&
+            !m.isDeleted &&
+            m.content.toLowerCase().includes(lowerQuery));
+        if (options?.cursor) {
+            matched = matched.filter((m) => m.createdAt < options.cursor);
+        }
+        matched.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        const page = matched.slice(0, limit);
+        const hasMore = matched.length > limit;
+        const lastItem = page[page.length - 1];
+        return {
+            items: page.map((m) => this.recordToMessage(m)),
+            cursor: hasMore && lastItem ? lastItem.createdAt : undefined,
+            hasMore,
+        };
+    }
+    async searchInConversation(conversationId, userId, query, options) {
+        await this.assertParticipant(conversationId, userId);
+        const limit = this.clampLimit(options?.limit);
+        const lowerQuery = query.toLowerCase();
+        let messages = await this.messagesCollection
+            .find({ conversationId })
+            .exec();
+        messages = messages.filter((m) => !m.isDeleted && m.content.toLowerCase().includes(lowerQuery));
+        if (options?.cursor) {
+            messages = messages.filter((m) => m.createdAt < options.cursor);
+        }
+        messages.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        const page = messages.slice(0, limit);
+        const hasMore = messages.length > limit;
+        const lastItem = page[page.length - 1];
+        return {
+            items: page.map((m) => this.recordToMessage(m)),
+            cursor: hasMore && lastItem ? lastItem.createdAt : undefined,
+            hasMore,
+        };
+    }
+    // ═══════════════════════════════════════════════════════
+    // Group Conversation Management (Req 40.1-40.12)
+    // ═══════════════════════════════════════════════════════
+    async addParticipants(conversationId, adminId, userIds) {
+        const conv = await this.assertParticipant(conversationId, adminId);
+        await this.assertGroupAdmin(conv, adminId);
+        const newParticipants = userIds.filter((id) => !conv.participantIds.includes(id));
+        if (newParticipants.length === 0)
+            return;
+        const totalAfter = conv.participantIds.length + newParticipants.length;
+        if (totalAfter > brighthub_lib_1.MAX_GROUP_PARTICIPANTS) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.GroupParticipantLimitExceeded, `Group cannot exceed ${brighthub_lib_1.MAX_GROUP_PARTICIPANTS} participants`);
+        }
+        const now = new Date().toISOString();
+        const updatedParticipants = [...conv.participantIds, ...newParticipants];
+        await this.conversationsCollection
+            .updateOne({ _id: conversationId }, {
+            participantIds: updatedParticipants,
+            updatedAt: now,
+        })
+            .exec();
+        for (const uid of newParticipants) {
+            await this.participantsCollection.create({
+                _id: (0, crypto_1.randomUUID)(),
+                conversationId,
+                userId: uid,
+                role: brighthub_lib_1.GroupParticipantRole.Participant,
+                notificationsEnabled: true,
+                joinedAt: now,
+            });
+        }
+    }
+    async removeParticipant(conversationId, adminId, userId) {
+        const conv = await this.assertParticipant(conversationId, adminId);
+        await this.assertGroupAdmin(conv, adminId);
+        if (!conv.participantIds.includes(userId)) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.NotParticipant, 'User is not a participant in this group');
+        }
+        const now = new Date().toISOString();
+        const updatedParticipants = conv.participantIds.filter((id) => id !== userId);
+        const updatedAdmins = (conv.adminIds ?? []).filter((id) => id !== userId);
+        await this.conversationsCollection
+            .updateOne({ _id: conversationId }, {
+            participantIds: updatedParticipants,
+            adminIds: updatedAdmins,
+            updatedAt: now,
+        })
+            .exec();
+        // Remove participant record
+        const participants = await this.participantsCollection
+            .find({ conversationId })
+            .exec();
+        const participantRecord = participants.find((p) => p.userId === userId);
+        if (participantRecord) {
+            await this.participantsCollection
+                .deleteOne({ _id: participantRecord._id })
+                .exec();
+        }
+    }
+    async promoteToAdmin(conversationId, adminId, userId) {
+        const conv = await this.assertParticipant(conversationId, adminId);
+        await this.assertGroupAdmin(conv, adminId);
+        if (!conv.participantIds.includes(userId)) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.NotParticipant, 'User is not a participant in this group');
+        }
+        if (conv.adminIds?.includes(userId)) {
+            return; // Already admin, idempotent
+        }
+        const updatedAdmins = [...(conv.adminIds ?? []), userId];
+        await this.conversationsCollection
+            .updateOne({ _id: conversationId }, {
+            adminIds: updatedAdmins,
+            updatedAt: new Date().toISOString(),
+        })
+            .exec();
+        // Update participant role
+        const participants = await this.participantsCollection
+            .find({ conversationId })
+            .exec();
+        const participantRecord = participants.find((p) => p.userId === userId);
+        if (participantRecord) {
+            await this.participantsCollection
+                .updateOne({ _id: participantRecord._id }, {
+                role: brighthub_lib_1.GroupParticipantRole.Admin,
+            })
+                .exec();
+        }
+    }
+    async demoteFromAdmin(conversationId, adminId, userId) {
+        const conv = await this.assertParticipant(conversationId, adminId);
+        await this.assertGroupAdmin(conv, adminId);
+        if (!conv.adminIds?.includes(userId)) {
+            return; // Not admin, idempotent
+        }
+        // Prevent demoting the last admin
+        if (conv.adminIds.length <= 1) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.LastAdminCannotLeave, 'Cannot demote the last admin');
+        }
+        const updatedAdmins = conv.adminIds.filter((id) => id !== userId);
+        await this.conversationsCollection
+            .updateOne({ _id: conversationId }, {
+            adminIds: updatedAdmins,
+            updatedAt: new Date().toISOString(),
+        })
+            .exec();
+        // Update participant role
+        const participants = await this.participantsCollection
+            .find({ conversationId })
+            .exec();
+        const participantRecord = participants.find((p) => p.userId === userId);
+        if (participantRecord) {
+            await this.participantsCollection
+                .updateOne({ _id: participantRecord._id }, {
+                role: brighthub_lib_1.GroupParticipantRole.Participant,
+            })
+                .exec();
+        }
+    }
+    async leaveGroup(conversationId, userId) {
+        const conv = await this.assertParticipant(conversationId, userId);
+        if (conv.type !== brighthub_lib_1.ConversationType.Group) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.NotAdmin, 'Cannot leave a direct conversation');
+        }
+        // If user is the last admin, they can't leave
+        if (conv.adminIds?.includes(userId) &&
+            conv.adminIds.length === 1 &&
+            conv.participantIds.length > 1) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.LastAdminCannotLeave, 'Last admin must promote another admin before leaving');
+        }
+        const now = new Date().toISOString();
+        const updatedParticipants = conv.participantIds.filter((id) => id !== userId);
+        const updatedAdmins = (conv.adminIds ?? []).filter((id) => id !== userId);
+        await this.conversationsCollection
+            .updateOne({ _id: conversationId }, {
+            participantIds: updatedParticipants,
+            adminIds: updatedAdmins,
+            updatedAt: now,
+        })
+            .exec();
+        // Remove participant record
+        const participants = await this.participantsCollection
+            .find({ conversationId })
+            .exec();
+        const participantRecord = participants.find((p) => p.userId === userId);
+        if (participantRecord) {
+            await this.participantsCollection
+                .deleteOne({ _id: participantRecord._id })
+                .exec();
+        }
+    }
+    async updateGroupSettings(conversationId, adminId, updates) {
+        const conv = await this.assertParticipant(conversationId, adminId);
+        await this.assertGroupAdmin(conv, adminId);
+        if (updates.name !== undefined && updates.name.trim().length === 0) {
+            throw new brighthub_lib_1.MessagingServiceError(brighthub_lib_1.MessagingErrorCode.InvalidGroupName, 'Group name cannot be empty');
+        }
+        const now = new Date().toISOString();
+        const updateFields = { updatedAt: now };
+        if (updates.name !== undefined)
+            updateFields.name = updates.name.trim();
+        if (updates.avatarUrl !== undefined)
+            updateFields.avatarUrl = updates.avatarUrl;
+        await this.conversationsCollection
+            .updateOne({ _id: conversationId }, updateFields)
+            .exec();
+        const updated = {
+            ...conv,
+            ...updateFields,
+        };
+        return this.recordToGroupConversation(updated);
+    }
+}
+exports.MessagingService = MessagingService;
+// ═══════════════════════════════════════════════════════
+// Factory function
+// ═══════════════════════════════════════════════════════
+/**
+ * Create a new MessagingService instance
+ * @param application Application with database collections
+ * @returns MessagingService instance
+ */
+function createMessagingService(application) {
+    return new MessagingService(application);
+}
+//# sourceMappingURL=messagingService.js.map