@brightchain/brightchain-api-lib 0.23.25 → 0.24.0

package/src/lib/controllers/api/brighthub/messagingController.js

@@ -0,0 +1,1077 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrightHubMessagingController = void 0;
+const brighthub_lib_1 = require("@brightchain/brighthub-lib");
+const node_express_suite_1 = require("@digitaldefiance/node-express-suite");
+const errorResponse_1 = require("../../../utils/errorResponse");
+const base_1 = require("../../base");
+/**
+ * Controller for BrightHub messaging operations.
+ *
+ * Provides REST API endpoints for conversations, messages, reactions,
+ * read receipts, message requests, and group management.
+ *
+ * @requirements 45.1-45.28
+ */
+class BrightHubMessagingController extends base_1.BaseController {
+    messagingService = null;
+    constructor(application) {
+        super(application);
+    }
+    setMessagingService(service) {
+        this.messagingService = service;
+    }
+    getMessagingService() {
+        if (!this.messagingService)
+            throw new Error('MessagingService not initialized');
+        return this.messagingService;
+    }
+    mapMessagingError(error) {
+        switch (error.code) {
+            case brighthub_lib_1.MessagingErrorCode.ConversationNotFound:
+            case brighthub_lib_1.MessagingErrorCode.MessageNotFound:
+            case brighthub_lib_1.MessagingErrorCode.MessageRequestNotFound:
+            case brighthub_lib_1.MessagingErrorCode.ReactionNotFound:
+                return (0, errorResponse_1.notFoundError)('Resource', 'unknown');
+            case brighthub_lib_1.MessagingErrorCode.NotParticipant:
+            case brighthub_lib_1.MessagingErrorCode.Unauthorized:
+            case brighthub_lib_1.MessagingErrorCode.NotAdmin:
+            case brighthub_lib_1.MessagingErrorCode.UserBlocked:
+                return (0, errorResponse_1.forbiddenError)(error.message);
+            case brighthub_lib_1.MessagingErrorCode.EmptyContent:
+            case brighthub_lib_1.MessagingErrorCode.ContentTooLong:
+            case brighthub_lib_1.MessagingErrorCode.TooManyAttachments:
+            case brighthub_lib_1.MessagingErrorCode.AttachmentSizeTooLarge:
+            case brighthub_lib_1.MessagingErrorCode.InvalidMediaFormat:
+            case brighthub_lib_1.MessagingErrorCode.ReactionLimitExceeded:
+            case brighthub_lib_1.MessagingErrorCode.ReactionAlreadyExists:
+            case brighthub_lib_1.MessagingErrorCode.PinLimitExceeded:
+            case brighthub_lib_1.MessagingErrorCode.AlreadyPinned:
+            case brighthub_lib_1.MessagingErrorCode.NotPinned:
+            case brighthub_lib_1.MessagingErrorCode.AlreadyArchived:
+            case brighthub_lib_1.MessagingErrorCode.NotArchived:
+            case brighthub_lib_1.MessagingErrorCode.AlreadyMuted:
+            case brighthub_lib_1.MessagingErrorCode.NotMuted:
+            case brighthub_lib_1.MessagingErrorCode.GroupParticipantLimitExceeded:
+            case brighthub_lib_1.MessagingErrorCode.AlreadyParticipant:
+            case brighthub_lib_1.MessagingErrorCode.InvalidGroupName:
+            case brighthub_lib_1.MessagingErrorCode.ConversationAlreadyExists:
+            case brighthub_lib_1.MessagingErrorCode.MessageRequestAlreadyExists:
+            case brighthub_lib_1.MessagingErrorCode.MessageAlreadyDeleted:
+            case brighthub_lib_1.MessagingErrorCode.EditWindowExpired:
+            case brighthub_lib_1.MessagingErrorCode.LastAdminCannotLeave:
+                return (0, errorResponse_1.validationError)(error.message);
+            default:
+                return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    parsePaginationOptions(query) {
+        const options = {};
+        if (query['cursor'])
+            options.cursor = query['cursor'];
+        if (query['limit'])
+            options.limit = parseInt(query['limit'], 10);
+        return options;
+    }
+    initRouteDefinitions() {
+        this.routeDefinitions = [
+            // ── Core Messaging (21.5) ──
+            (0, node_express_suite_1.routeConfig)('get', '/conversations', {
+                handlerKey: 'getConversations',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Get conversations',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: {
+                            schema: 'ConversationsResponse',
+                            description: 'Conversations retrieved',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/conversations', {
+                handlerKey: 'createConversation',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Create a conversation',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        201: {
+                            schema: 'ConversationResponse',
+                            description: 'Conversation created',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('get', '/conversations/:id', {
+                handlerKey: 'getConversation',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Get a conversation with messages',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: {
+                            schema: 'ConversationResponse',
+                            description: 'Conversation retrieved',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('delete', '/conversations/:id', {
+                handlerKey: 'deleteConversation',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Delete a conversation',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        204: {
+                            schema: 'EmptyResponse',
+                            description: 'Conversation deleted',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/conversations/:id/messages', {
+                handlerKey: 'sendMessage',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Send a message',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        201: { schema: 'MessageResponse', description: 'Message sent' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('put', '/:messageId', {
+                handlerKey: 'editMessage',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Edit a message',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: { schema: 'MessageResponse', description: 'Message edited' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('delete', '/:messageId', {
+                handlerKey: 'deleteMessage',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Delete a message',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        204: { schema: 'EmptyResponse', description: 'Message deleted' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/:messageId/reactions', {
+                handlerKey: 'addReaction',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Add a reaction to a message',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        201: { schema: 'ReactionResponse', description: 'Reaction added' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('delete', '/:messageId/reactions/:emoji', {
+                handlerKey: 'removeReaction',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Remove a reaction from a message',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: { schema: 'MessageResponse', description: 'Reaction removed' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/conversations/:id/read', {
+                handlerKey: 'markAsRead',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Mark messages as read',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: {
+                            schema: 'ReadReceiptResponse',
+                            description: 'Marked as read',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/conversations/:id/typing', {
+                handlerKey: 'sendTypingIndicator',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Send typing indicator',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: {
+                            schema: 'TypingResponse',
+                            description: 'Typing indicator sent',
+                        },
+                    },
+                },
+            }),
+            // ── Additional Messaging (21.6) ──
+            (0, node_express_suite_1.routeConfig)('get', '/requests', {
+                handlerKey: 'getMessageRequests',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Get message requests',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: {
+                            schema: 'MessageRequestsResponse',
+                            description: 'Requests retrieved',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/requests/:id/accept', {
+                handlerKey: 'acceptMessageRequest',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Accept a message request',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: {
+                            schema: 'ConversationResponse',
+                            description: 'Request accepted',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/requests/:id/decline', {
+                handlerKey: 'declineMessageRequest',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Decline a message request',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: { schema: 'MessageResponse', description: 'Request declined' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/conversations/:id/pin', {
+                handlerKey: 'pinConversation',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Pin a conversation',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: {
+                            schema: 'MessageResponse',
+                            description: 'Conversation pinned',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('delete', '/conversations/:id/pin', {
+                handlerKey: 'unpinConversation',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Unpin a conversation',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: {
+                            schema: 'MessageResponse',
+                            description: 'Conversation unpinned',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/conversations/:id/archive', {
+                handlerKey: 'archiveConversation',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Archive a conversation',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: {
+                            schema: 'MessageResponse',
+                            description: 'Conversation archived',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/conversations/:id/unarchive', {
+                handlerKey: 'unarchiveConversation',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Unarchive a conversation',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: {
+                            schema: 'MessageResponse',
+                            description: 'Conversation unarchived',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/conversations/:id/mute', {
+                handlerKey: 'muteConversation',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Mute a conversation',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: {
+                            schema: 'MessageResponse',
+                            description: 'Conversation muted',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('delete', '/conversations/:id/mute', {
+                handlerKey: 'unmuteConversation',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Unmute a conversation',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: {
+                            schema: 'MessageResponse',
+                            description: 'Conversation unmuted',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/:messageId/report', {
+                handlerKey: 'reportMessage',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Report a message',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: { schema: 'MessageResponse', description: 'Message reported' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('get', '/conversations/:id/search', {
+                handlerKey: 'searchInConversation',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Search within a conversation',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: { schema: 'MessagesResponse', description: 'Search results' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('get', '/search', {
+                handlerKey: 'searchAllMessages',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Search all conversations',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: { schema: 'MessagesResponse', description: 'Search results' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/conversations/:id/participants', {
+                handlerKey: 'addParticipants',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Add participants to group',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: {
+                            schema: 'MessageResponse',
+                            description: 'Participants added',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('delete', '/conversations/:id/participants/:userId', {
+                handlerKey: 'removeParticipant',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Remove a participant from group',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: {
+                            schema: 'MessageResponse',
+                            description: 'Participant removed',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('put', '/conversations/:id/settings', {
+                handlerKey: 'updateGroupSettings',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Update group settings',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        200: {
+                            schema: 'ConversationResponse',
+                            description: 'Settings updated',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/:messageId/forward', {
+                handlerKey: 'forwardMessage',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Forward a message',
+                    tags: ['BrightHub Messaging'],
+                    responses: {
+                        201: {
+                            schema: 'MessageResponse',
+                            description: 'Message forwarded',
+                        },
+                    },
+                },
+            }),
+        ];
+        node_express_suite_1.ControllerRegistry.register('/brighthub/messages', 'BrightHubMessagingController', this.routeDefinitions);
+        this.handlers = {
+            getConversations: this.handleGetConversations.bind(this),
+            createConversation: this.handleCreateConversation.bind(this),
+            getConversation: this.handleGetConversation.bind(this),
+            deleteConversation: this.handleDeleteConversation.bind(this),
+            sendMessage: this.handleSendMessage.bind(this),
+            editMessage: this.handleEditMessage.bind(this),
+            deleteMessage: this.handleDeleteMessage.bind(this),
+            addReaction: this.handleAddReaction.bind(this),
+            removeReaction: this.handleRemoveReaction.bind(this),
+            markAsRead: this.handleMarkAsRead.bind(this),
+            sendTypingIndicator: this.handleSendTypingIndicator.bind(this),
+            getMessageRequests: this.handleGetMessageRequests.bind(this),
+            acceptMessageRequest: this.handleAcceptMessageRequest.bind(this),
+            declineMessageRequest: this.handleDeclineMessageRequest.bind(this),
+            pinConversation: this.handlePinConversation.bind(this),
+            unpinConversation: this.handleUnpinConversation.bind(this),
+            archiveConversation: this.handleArchiveConversation.bind(this),
+            unarchiveConversation: this.handleUnarchiveConversation.bind(this),
+            muteConversation: this.handleMuteConversation.bind(this),
+            unmuteConversation: this.handleUnmuteConversation.bind(this),
+            reportMessage: this.handleReportMessage.bind(this),
+            searchInConversation: this.handleSearchInConversation.bind(this),
+            searchAllMessages: this.handleSearchAllMessages.bind(this),
+            addParticipants: this.handleAddParticipants.bind(this),
+            removeParticipant: this.handleRemoveParticipant.bind(this),
+            updateGroupSettings: this.handleUpdateGroupSettings.bind(this),
+            forwardMessage: this.handleForwardMessage.bind(this),
+        };
+    }
+    // ═══════════════════════════════════════════════════════
+    // Core Messaging Handlers (21.5)
+    // ═══════════════════════════════════════════════════════
+    async handleGetConversations(req) {
+        try {
+            const typedReq = req;
+            const userId = typedReq.query['userId'];
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required query parameter: userId');
+            const options = this.parsePaginationOptions(typedReq.query);
+            const result = await this.getMessagingService().getConversations(userId, options);
+            return {
+                statusCode: 200,
+                response: {
+                    message: 'OK',
+                    data: {
+                        conversations: result.items,
+                        cursor: result.cursor,
+                        hasMore: result.hasMore,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleCreateConversation(req) {
+        try {
+            const { userId, otherUserId, participantIds, type, name, avatarUrl } = req.body;
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required field: userId');
+            const service = this.getMessagingService();
+            if (type === 'group') {
+                if (!participantIds || !Array.isArray(participantIds))
+                    return (0, errorResponse_1.validationError)('Missing required field: participantIds');
+                if (!name)
+                    return (0, errorResponse_1.validationError)('Missing required field: name for group conversation');
+                const conversation = await service.createGroupConversation(userId, participantIds, { name, avatarUrl });
+                return {
+                    statusCode: 201,
+                    response: {
+                        message: 'Group conversation created',
+                        data: conversation,
+                    },
+                };
+            }
+            else {
+                if (!otherUserId)
+                    return (0, errorResponse_1.validationError)('Missing required field: otherUserId');
+                const conversation = await service.createDirectConversation(userId, otherUserId);
+                return {
+                    statusCode: 201,
+                    response: { message: 'Conversation created', data: conversation },
+                };
+            }
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleGetConversation(req) {
+        try {
+            const { id } = req.params;
+            const typedReq = req;
+            const userId = typedReq.query['userId'];
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required query parameter: userId');
+            const conversation = await this.getMessagingService().getConversation(id, userId);
+            return {
+                statusCode: 200,
+                response: { message: 'OK', data: conversation },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleDeleteConversation(req) {
+        try {
+            const { id } = req.params;
+            const { userId } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required field: userId');
+            await this.getMessagingService().deleteConversation(id, userId);
+            return { statusCode: 204, response: { message: 'Conversation deleted' } };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleSendMessage(req) {
+        try {
+            const { id } = req.params;
+            const { senderId, content, attachments, replyToMessageId, forwardedFromId, } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!senderId)
+                return (0, errorResponse_1.validationError)('Missing required field: senderId');
+            if (content === undefined || content === null)
+                return (0, errorResponse_1.validationError)('Missing required field: content');
+            const options = {};
+            if (attachments)
+                options.attachments = attachments;
+            if (replyToMessageId)
+                options.replyToMessageId = replyToMessageId;
+            if (forwardedFromId)
+                options.forwardedFromId = forwardedFromId;
+            const message = await this.getMessagingService().sendMessage(id, senderId, content, options);
+            return {
+                statusCode: 201,
+                response: { message: 'Message sent', data: message },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleEditMessage(req) {
+        try {
+            const { messageId } = req.params;
+            const { userId, content } = req.body;
+            if (!messageId)
+                return (0, errorResponse_1.validationError)('Missing required parameter: messageId');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required field: userId');
+            if (content === undefined || content === null)
+                return (0, errorResponse_1.validationError)('Missing required field: content');
+            const message = await this.getMessagingService().editMessage(messageId, userId, content);
+            return {
+                statusCode: 200,
+                response: { message: 'Message edited', data: message },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleDeleteMessage(req) {
+        try {
+            const { messageId } = req.params;
+            const { userId } = req.body;
+            if (!messageId)
+                return (0, errorResponse_1.validationError)('Missing required parameter: messageId');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required field: userId');
+            await this.getMessagingService().deleteMessage(messageId, userId);
+            return { statusCode: 204, response: { message: 'Message deleted' } };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleAddReaction(req) {
+        try {
+            const { messageId } = req.params;
+            const { userId, emoji } = req.body;
+            if (!messageId)
+                return (0, errorResponse_1.validationError)('Missing required parameter: messageId');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required field: userId');
+            if (!emoji)
+                return (0, errorResponse_1.validationError)('Missing required field: emoji');
+            const reaction = await this.getMessagingService().addReaction(messageId, userId, emoji);
+            return {
+                statusCode: 201,
+                response: {
+                    message: 'Reaction added',
+                    data: reaction,
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleRemoveReaction(req) {
+        try {
+            const { messageId, emoji } = req.params;
+            const typedReq = req;
+            const userId = typedReq.query['userId'];
+            if (!messageId)
+                return (0, errorResponse_1.validationError)('Missing required parameter: messageId');
+            if (!emoji)
+                return (0, errorResponse_1.validationError)('Missing required parameter: emoji');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required query parameter: userId');
+            await this.getMessagingService().removeReaction(messageId, userId, decodeURIComponent(emoji));
+            return { statusCode: 200, response: { message: 'Reaction removed' } };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleMarkAsRead(req) {
+        try {
+            const { id } = req.params;
+            const { userId, messageId } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required field: userId');
+            if (!messageId)
+                return (0, errorResponse_1.validationError)('Missing required field: messageId');
+            const receipt = await this.getMessagingService().markAsRead(id, userId, messageId);
+            return {
+                statusCode: 200,
+                response: {
+                    message: 'Marked as read',
+                    data: receipt,
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleSendTypingIndicator(req) {
+        try {
+            const { id } = req.params;
+            const { userId } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required field: userId');
+            const result = await this.getMessagingService().sendTypingIndicator(id, userId);
+            return {
+                statusCode: 200,
+                response: {
+                    message: 'Typing indicator sent',
+                    data: result,
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    // ═══════════════════════════════════════════════════════
+    // Additional Messaging Handlers (21.6)
+    // ═══════════════════════════════════════════════════════
+    async handleGetMessageRequests(_req) {
+        // Message requests are created via createMessageRequest on the service.
+        // Listing them requires a dedicated query method not yet on the interface.
+        // Return a placeholder until the service method is available.
+        return {
+            statusCode: 200,
+            response: {
+                message: 'OK',
+                data: { items: [], hasMore: false },
+            },
+        };
+    }
+    async handleAcceptMessageRequest(req) {
+        try {
+            const { id } = req.params;
+            const { userId } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required field: userId');
+            const conversation = await this.getMessagingService().acceptMessageRequest(id, userId);
+            return {
+                statusCode: 200,
+                response: { message: 'Message request accepted', data: conversation },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleDeclineMessageRequest(req) {
+        try {
+            const { id } = req.params;
+            const { userId } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required field: userId');
+            await this.getMessagingService().declineMessageRequest(id, userId);
+            return {
+                statusCode: 200,
+                response: { message: 'Message request declined' },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handlePinConversation(req) {
+        try {
+            const { id } = req.params;
+            const { userId } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required field: userId');
+            await this.getMessagingService().pinConversation(id, userId);
+            return { statusCode: 200, response: { message: 'Conversation pinned' } };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleUnpinConversation(req) {
+        try {
+            const { id } = req.params;
+            const typedReq = req;
+            const userId = typedReq.query['userId'];
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required query parameter: userId');
+            await this.getMessagingService().unpinConversation(id, userId);
+            return {
+                statusCode: 200,
+                response: { message: 'Conversation unpinned' },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleArchiveConversation(req) {
+        try {
+            const { id } = req.params;
+            const { userId } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required field: userId');
+            await this.getMessagingService().archiveConversation(id, userId);
+            return {
+                statusCode: 200,
+                response: { message: 'Conversation archived' },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleUnarchiveConversation(req) {
+        try {
+            const { id } = req.params;
+            const { userId } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required field: userId');
+            await this.getMessagingService().unarchiveConversation(id, userId);
+            return {
+                statusCode: 200,
+                response: { message: 'Conversation unarchived' },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleMuteConversation(req) {
+        try {
+            const { id } = req.params;
+            const { userId, expiresAt } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required field: userId');
+            await this.getMessagingService().muteConversation(id, userId, expiresAt);
+            return { statusCode: 200, response: { message: 'Conversation muted' } };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleUnmuteConversation(req) {
+        try {
+            const { id } = req.params;
+            const typedReq = req;
+            const userId = typedReq.query['userId'];
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required query parameter: userId');
+            await this.getMessagingService().unmuteConversation(id, userId);
+            return { statusCode: 200, response: { message: 'Conversation unmuted' } };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleReportMessage(_req) {
+        // Message reporting requires a dedicated service method not yet on the interface.
+        // Return acknowledgment for now.
+        return { statusCode: 200, response: { message: 'Message reported' } };
+    }
+    async handleSearchInConversation(req) {
+        try {
+            const { id } = req.params;
+            const typedReq = req;
+            const userId = typedReq.query['userId'];
+            const query = typedReq.query['q'];
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required query parameter: userId');
+            if (!query)
+                return (0, errorResponse_1.validationError)('Missing required query parameter: q');
+            const options = this.parsePaginationOptions(typedReq.query);
+            const result = await this.getMessagingService().searchInConversation(id, userId, query, options);
+            return {
+                statusCode: 200,
+                response: {
+                    message: 'OK',
+                    data: {
+                        messages: result.items,
+                        cursor: result.cursor,
+                        hasMore: result.hasMore,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleSearchAllMessages(req) {
+        try {
+            const typedReq = req;
+            const userId = typedReq.query['userId'];
+            const query = typedReq.query['q'];
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required query parameter: userId');
+            if (!query)
+                return (0, errorResponse_1.validationError)('Missing required query parameter: q');
+            const options = this.parsePaginationOptions(typedReq.query);
+            const result = await this.getMessagingService().searchMessages(userId, query, options);
+            return {
+                statusCode: 200,
+                response: {
+                    message: 'OK',
+                    data: {
+                        messages: result.items,
+                        cursor: result.cursor,
+                        hasMore: result.hasMore,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleAddParticipants(req) {
+        try {
+            const { id } = req.params;
+            const { adminId, userIds } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!adminId)
+                return (0, errorResponse_1.validationError)('Missing required field: adminId');
+            if (!userIds || !Array.isArray(userIds))
+                return (0, errorResponse_1.validationError)('Missing required field: userIds (array)');
+            await this.getMessagingService().addParticipants(id, adminId, userIds);
+            return { statusCode: 200, response: { message: 'Participants added' } };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleRemoveParticipant(req) {
+        try {
+            const { id, userId: targetUserId } = req.params;
+            const typedReq = req;
+            const adminId = typedReq.query['adminId'];
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!targetUserId)
+                return (0, errorResponse_1.validationError)('Missing required parameter: userId');
+            if (!adminId)
+                return (0, errorResponse_1.validationError)('Missing required query parameter: adminId');
+            await this.getMessagingService().removeParticipant(id, adminId, targetUserId);
+            return { statusCode: 200, response: { message: 'Participant removed' } };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleUpdateGroupSettings(req) {
+        try {
+            const { id } = req.params;
+            const { adminId, name, avatarUrl } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!adminId)
+                return (0, errorResponse_1.validationError)('Missing required field: adminId');
+            const updates = {};
+            if (name !== undefined)
+                updates.name = name;
+            if (avatarUrl !== undefined)
+                updates.avatarUrl = avatarUrl;
+            const conversation = await this.getMessagingService().updateGroupSettings(id, adminId, updates);
+            return {
+                statusCode: 200,
+                response: { message: 'Group settings updated', data: conversation },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleForwardMessage(req) {
+        try {
+            const { messageId } = req.params;
+            const { userId, targetConversationId } = req.body;
+            if (!messageId)
+                return (0, errorResponse_1.validationError)('Missing required parameter: messageId');
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required field: userId');
+            if (!targetConversationId)
+                return (0, errorResponse_1.validationError)('Missing required field: targetConversationId');
+            // Forward by sending a new message with forwardedFromId
+            const message = await this.getMessagingService().sendMessage(targetConversationId, userId, '', { forwardedFromId: messageId });
+            return {
+                statusCode: 201,
+                response: { message: 'Message forwarded', data: message },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.MessagingServiceError)
+                return this.mapMessagingError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+}
+exports.BrightHubMessagingController = BrightHubMessagingController;
+//# sourceMappingURL=messagingController.js.map