@brightchain/brightchain-api-lib 0.14.0 → 0.15.0

package/src/lib/controllers/api/channels.js

@@ -0,0 +1,701 @@
+"use strict";
+/**
+ * ChannelController — REST API for channel management.
+ *
+ * Routes:
+ *   POST   /                                         — Create a channel
+ *   GET    /                                         — List discoverable channels
+ *   GET    /:channelId                               — Get channel metadata
+ *   PUT    /:channelId                               — Update channel settings
+ *   DELETE /:channelId                               — Delete channel
+ *   POST   /:channelId/join                          — Join a channel
+ *   POST   /:channelId/leave                         — Leave a channel
+ *   POST   /:channelId/messages                      — Send message
+ *   GET    /:channelId/messages                      — Get message history
+ *   GET    /:channelId/messages/search               — Search messages
+ *   POST   /:channelId/invites                       — Generate invite token
+ *   POST   /:channelId/invites/:token/redeem         — Redeem invite token
+ *   PUT    /:channelId/roles/:memberId               — Assign role
+ *   POST   /:channelId/messages/:messageId/reactions  — Add reaction
+ *   DELETE /:channelId/messages/:messageId/reactions/:reactionId — Remove reaction
+ *   PUT    /:channelId/messages/:messageId            — Edit message
+ *   POST   /:channelId/messages/:messageId/pin        — Pin message
+ *   DELETE /:channelId/messages/:messageId/pin        — Unpin message
+ *   POST   /:channelId/mute/:memberId                — Mute a member
+ *   POST   /:channelId/kick/:memberId                — Kick a member
+ *
+ * Requirements: 4.1, 4.2, 4.3, 4.4, 4.5, 5.1, 5.2, 5.3, 5.4, 5.5
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelController = void 0;
+const channelService_1 = require("@brightchain/brightchain-lib/lib/services/communication/channelService");
+const node_express_suite_1 = require("@digitaldefiance/node-express-suite");
+const communicationValidation_1 = require("../../utils/communicationValidation");
+const errorResponse_1 = require("../../utils/errorResponse");
+const base_1 = require("../base");
+/**
+ * Controller for channel operations.
+ *
+ * @requirements 4.1, 4.2, 4.3, 4.4, 4.5, 5.1, 5.2, 5.3, 5.4, 5.5
+ */
+class ChannelController extends base_1.BaseController {
+    constructor(application) {
+        super(application);
+        this.channelService = null;
+        this.permissionService = null;
+    }
+    setChannelService(service) {
+        this.channelService = service;
+    }
+    setPermissionService(service) {
+        this.permissionService = service;
+    }
+    getChannelService() {
+        if (!this.channelService) {
+            throw new Error('ChannelService not initialized');
+        }
+        return this.channelService;
+    }
+    getPermissionService() {
+        if (!this.permissionService) {
+            throw new Error('PermissionService not initialized');
+        }
+        return this.permissionService;
+    }
+    /**
+     * Extract the authenticated member ID from the request.
+     * Falls back to body/query memberId for testing.
+     */
+    getMemberId(req) {
+        const body = req.body;
+        if (body && typeof body === 'object') {
+            const bodyRecord = body;
+            if (typeof bodyRecord['memberId'] === 'string')
+                return bodyRecord['memberId'];
+            if (typeof bodyRecord['requesterId'] === 'string')
+                return bodyRecord['requesterId'];
+        }
+        const query = req.query;
+        if (query && typeof query.memberId === 'string')
+            return query.memberId;
+        throw new Error('No authenticated user');
+    }
+    initRouteDefinitions() {
+        const noAuth = {
+            useAuthentication: false,
+            useCryptoAuthentication: false,
+        };
+        this.routeDefinitions = [
+            (0, node_express_suite_1.routeConfig)('post', '/', {
+                ...noAuth,
+                handlerKey: 'createChannel',
+                validation: () => communicationValidation_1.createChannelValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('get', '/', {
+                ...noAuth,
+                handlerKey: 'listChannels',
+                validation: () => communicationValidation_1.listChannelsValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('get', '/:channelId', {
+                ...noAuth,
+                handlerKey: 'getChannel',
+                validation: () => communicationValidation_1.channelIdParamValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('put', '/:channelId', {
+                ...noAuth,
+                handlerKey: 'updateChannel',
+                validation: () => communicationValidation_1.updateChannelValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('delete', '/:channelId', {
+                ...noAuth,
+                handlerKey: 'deleteChannel',
+                validation: () => communicationValidation_1.channelIdParamValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/:channelId/join', {
+                ...noAuth,
+                handlerKey: 'joinChannel',
+                validation: () => communicationValidation_1.joinChannelValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/:channelId/leave', {
+                ...noAuth,
+                handlerKey: 'leaveChannel',
+                validation: () => communicationValidation_1.leaveChannelValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/:channelId/messages', {
+                ...noAuth,
+                handlerKey: 'sendMessage',
+                validation: () => communicationValidation_1.sendChannelMessageValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('get', '/:channelId/messages', {
+                ...noAuth,
+                handlerKey: 'getMessages',
+                validation: () => communicationValidation_1.getChannelMessagesValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('get', '/:channelId/messages/search', {
+                ...noAuth,
+                handlerKey: 'searchMessages',
+                validation: () => communicationValidation_1.searchChannelMessagesValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/:channelId/invites', {
+                ...noAuth,
+                handlerKey: 'createInvite',
+                validation: () => communicationValidation_1.createInviteValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/:channelId/invites/:token/redeem', {
+                ...noAuth,
+                handlerKey: 'redeemInvite',
+                validation: () => communicationValidation_1.redeemInviteValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('put', '/:channelId/roles/:memberId', {
+                ...noAuth,
+                handlerKey: 'assignRole',
+                validation: () => communicationValidation_1.assignChannelRoleValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/:channelId/messages/:messageId/reactions', {
+                ...noAuth,
+                handlerKey: 'addReaction',
+                validation: () => communicationValidation_1.addChannelReactionValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('delete', '/:channelId/messages/:messageId/reactions/:reactionId', {
+                ...noAuth,
+                handlerKey: 'removeReaction',
+                validation: () => communicationValidation_1.removeChannelReactionValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('put', '/:channelId/messages/:messageId', {
+                ...noAuth,
+                handlerKey: 'editMessage',
+                validation: () => communicationValidation_1.editChannelMessageValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/:channelId/messages/:messageId/pin', {
+                ...noAuth,
+                handlerKey: 'pinMessage',
+                validation: () => communicationValidation_1.pinChannelMessageValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('delete', '/:channelId/messages/:messageId/pin', {
+                ...noAuth,
+                handlerKey: 'unpinMessage',
+                validation: () => communicationValidation_1.pinChannelMessageValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/:channelId/mute/:memberId', {
+                ...noAuth,
+                handlerKey: 'muteMember',
+                validation: () => communicationValidation_1.muteChannelMemberValidation,
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/:channelId/kick/:memberId', {
+                ...noAuth,
+                handlerKey: 'kickMember',
+                validation: () => communicationValidation_1.kickChannelMemberValidation,
+            }),
+        ];
+        this.handlers = {
+            createChannel: this.handleCreateChannel.bind(this),
+            listChannels: this.handleListChannels.bind(this),
+            getChannel: this.handleGetChannel.bind(this),
+            updateChannel: this.handleUpdateChannel.bind(this),
+            deleteChannel: this.handleDeleteChannel.bind(this),
+            joinChannel: this.handleJoinChannel.bind(this),
+            leaveChannel: this.handleLeaveChannel.bind(this),
+            sendMessage: this.handleSendMessage.bind(this),
+            getMessages: this.handleGetMessages.bind(this),
+            searchMessages: this.handleSearchMessages.bind(this),
+            createInvite: this.handleCreateInvite.bind(this),
+            redeemInvite: this.handleRedeemInvite.bind(this),
+            assignRole: this.handleAssignRole.bind(this),
+            addReaction: this.handleAddReaction.bind(this),
+            removeReaction: this.handleRemoveReaction.bind(this),
+            editMessage: this.handleEditMessage.bind(this),
+            pinMessage: this.handlePinMessage.bind(this),
+            unpinMessage: this.handleUnpinMessage.bind(this),
+            muteMember: this.handleMuteMember.bind(this),
+            kickMember: this.handleKickMember.bind(this),
+        };
+    }
+    // ─── Handlers ─────────────────────────────────────────────────────────
+    /** POST / — Create a channel. @requirements 4.1 */
+    async handleCreateChannel(req) {
+        try {
+            const { name, topic, visibility } = req.body;
+            if (!name || !visibility) {
+                return (0, errorResponse_1.validationError)('Missing required fields: name, visibility');
+            }
+            const memberId = this.getMemberId(req);
+            const channel = await this.getChannelService().createChannel(name, memberId, visibility, topic);
+            return {
+                statusCode: 201,
+                response: {
+                    status: 'success',
+                    data: channel,
+                    message: 'Channel created',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** GET / — List discoverable channels. @requirements 4.3, 5.1 */
+    async handleListChannels(req) {
+        try {
+            const { cursor, limit } = req.query;
+            const memberId = this.getMemberId(req);
+            const result = await this.getChannelService().listChannels(memberId, cursor, limit ? parseInt(limit, 10) : undefined);
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: result,
+                    message: 'Channels listed',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** GET /:channelId — Get channel metadata. */
+    async handleGetChannel(req) {
+        try {
+            const { channelId } = req.params;
+            const memberId = this.getMemberId(req);
+            const channel = await this.getChannelService().getChannel(channelId, memberId);
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: channel,
+                    message: 'Channel retrieved',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** PUT /:channelId — Update channel settings. @requirements 5.2 */
+    async handleUpdateChannel(req) {
+        try {
+            const { channelId } = req.params;
+            const { name, topic, visibility, historyVisibleToNewMembers } = req.body;
+            const memberId = this.getMemberId(req);
+            const channel = await this.getChannelService().updateChannel(channelId, memberId, { name, topic, visibility, historyVisibleToNewMembers });
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: channel,
+                    message: 'Channel updated',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** DELETE /:channelId — Delete channel. */
+    async handleDeleteChannel(req) {
+        try {
+            const { channelId } = req.params;
+            const memberId = this.getMemberId(req);
+            await this.getChannelService().deleteChannel(channelId, memberId);
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: { deleted: true },
+                    message: 'Channel deleted',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** POST /:channelId/join — Join a channel. @requirements 4.4, 4.5 */
+    async handleJoinChannel(req) {
+        try {
+            const { channelId } = req.params;
+            const memberId = this.getMemberId(req);
+            await this.getChannelService().joinChannel(channelId, memberId);
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: { joined: true },
+                    message: 'Joined channel',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** POST /:channelId/leave — Leave a channel. */
+    async handleLeaveChannel(req) {
+        try {
+            const { channelId } = req.params;
+            const memberId = this.getMemberId(req);
+            await this.getChannelService().leaveChannel(channelId, memberId);
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: { left: true },
+                    message: 'Left channel',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** POST /:channelId/messages — Send message. @requirements 4.2 */
+    async handleSendMessage(req) {
+        try {
+            const { channelId } = req.params;
+            const { content } = req.body;
+            if (!content) {
+                return (0, errorResponse_1.validationError)('Missing required field: content');
+            }
+            const memberId = this.getMemberId(req);
+            const message = await this.getChannelService().sendMessage(channelId, memberId, content);
+            return {
+                statusCode: 201,
+                response: {
+                    status: 'success',
+                    data: message,
+                    message: 'Message sent',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** GET /:channelId/messages — Get message history. */
+    async handleGetMessages(req) {
+        try {
+            const { channelId } = req.params;
+            const { cursor, limit } = req.query;
+            const memberId = this.getMemberId(req);
+            const result = await this.getChannelService().getMessages(channelId, memberId, cursor, limit ? parseInt(limit, 10) : undefined);
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: result,
+                    message: 'Messages retrieved',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** GET /:channelId/messages/search — Search messages. */
+    async handleSearchMessages(req) {
+        try {
+            const { channelId } = req.params;
+            const { query, cursor, limit } = req.query;
+            if (!query) {
+                return (0, errorResponse_1.validationError)('Missing required query parameter: query');
+            }
+            const memberId = this.getMemberId(req);
+            const result = await this.getChannelService().searchMessages(channelId, memberId, query, cursor, limit ? parseInt(limit, 10) : undefined);
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: result,
+                    message: 'Search results',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** POST /:channelId/invites — Generate invite token. @requirements 5.3 */
+    async handleCreateInvite(req) {
+        try {
+            const { channelId } = req.params;
+            const { maxUses, expiresInMs } = req.body;
+            const memberId = this.getMemberId(req);
+            const invite = await this.getChannelService().createInvite(channelId, memberId, maxUses, expiresInMs);
+            return {
+                statusCode: 201,
+                response: {
+                    status: 'success',
+                    data: invite,
+                    message: 'Invite created',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** POST /:channelId/invites/:token/redeem — Redeem invite. @requirements 5.4, 5.5 */
+    async handleRedeemInvite(req) {
+        try {
+            const { token } = req.params;
+            const memberId = this.getMemberId(req);
+            await this.getChannelService().redeemInvite(token, memberId);
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: { redeemed: true },
+                    message: 'Invite redeemed',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** PUT /:channelId/roles/:memberId — Assign role. */
+    async handleAssignRole(req) {
+        try {
+            const { channelId, memberId: targetId } = req.params;
+            const { role } = req.body;
+            if (!role) {
+                return (0, errorResponse_1.validationError)('Missing required field: role');
+            }
+            const requesterId = this.getMemberId(req);
+            const permService = this.getPermissionService();
+            if (!permService.hasPermission(requesterId, channelId, 'manage_roles')) {
+                return (0, errorResponse_1.forbiddenError)('Missing permission: manage_roles');
+            }
+            permService.assignRole(targetId, channelId, role);
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: { memberId: targetId, role },
+                    message: 'Role assigned',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** POST /:channelId/messages/:messageId/reactions — Add reaction. */
+    async handleAddReaction(req) {
+        try {
+            const { channelId, messageId } = req.params;
+            const { emoji } = req.body;
+            if (!emoji) {
+                return (0, errorResponse_1.validationError)('Missing required field: emoji');
+            }
+            const memberId = this.getMemberId(req);
+            const reactionId = await this.getChannelService().addReaction(channelId, messageId, memberId, emoji);
+            return {
+                statusCode: 201,
+                response: {
+                    status: 'success',
+                    data: { reactionId, emoji },
+                    message: 'Reaction added',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** DELETE /:channelId/messages/:messageId/reactions/:reactionId — Remove reaction. */
+    async handleRemoveReaction(req) {
+        try {
+            const { channelId, messageId, reactionId } = req
+                .params;
+            const memberId = this.getMemberId(req);
+            await this.getChannelService().removeReaction(channelId, messageId, memberId, reactionId);
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: { removed: true },
+                    message: 'Reaction removed',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** PUT /:channelId/messages/:messageId — Edit message. */
+    async handleEditMessage(req) {
+        try {
+            const { channelId, messageId } = req.params;
+            const { content } = req.body;
+            if (!content) {
+                return (0, errorResponse_1.validationError)('Missing required field: content');
+            }
+            const memberId = this.getMemberId(req);
+            const message = await this.getChannelService().editMessage(channelId, messageId, memberId, content);
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: message,
+                    message: 'Message edited',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** POST /:channelId/messages/:messageId/pin — Pin message. */
+    async handlePinMessage(req) {
+        try {
+            const { channelId, messageId } = req.params;
+            const memberId = this.getMemberId(req);
+            await this.getChannelService().pinMessage(channelId, messageId, memberId);
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: { pinned: true },
+                    message: 'Message pinned',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** DELETE /:channelId/messages/:messageId/pin — Unpin message. */
+    async handleUnpinMessage(req) {
+        try {
+            const { channelId, messageId } = req.params;
+            const memberId = this.getMemberId(req);
+            await this.getChannelService().unpinMessage(channelId, messageId, memberId);
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: { unpinned: true },
+                    message: 'Message unpinned',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** POST /:channelId/mute/:memberId — Mute a member. */
+    async handleMuteMember(req) {
+        try {
+            const { channelId, memberId: targetId } = req.params;
+            const { durationMs } = req.body;
+            if (!durationMs || durationMs <= 0) {
+                return (0, errorResponse_1.validationError)('Missing or invalid field: durationMs');
+            }
+            const requesterId = this.getMemberId(req);
+            await this.getChannelService().muteMember(channelId, requesterId, targetId, durationMs);
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: {
+                        muted: true,
+                        until: new Date(Date.now() + durationMs).toISOString(),
+                    },
+                    message: 'Member muted',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    /** POST /:channelId/kick/:memberId — Kick a member. */
+    async handleKickMember(req) {
+        try {
+            const { channelId, memberId: targetId } = req.params;
+            const requesterId = this.getMemberId(req);
+            await this.getChannelService().kickMember(channelId, requesterId, targetId);
+            return {
+                statusCode: 200,
+                response: {
+                    status: 'success',
+                    data: { kicked: true },
+                    message: 'Member kicked',
+                },
+            };
+        }
+        catch (error) {
+            return this.mapServiceError(error);
+        }
+    }
+    // ─── Error mapping ────────────────────────────────────────────────────
+    mapServiceError(error) {
+        if (error instanceof channelService_1.ChannelNotFoundError) {
+            return (0, errorResponse_1.notFoundError)('Channel', 'unknown');
+        }
+        if (error instanceof channelService_1.NotChannelMemberError) {
+            return (0, errorResponse_1.forbiddenError)(error.message);
+        }
+        if (error instanceof channelService_1.ChannelPermissionError) {
+            return (0, errorResponse_1.forbiddenError)(`Missing permission: ${error.missingPermission}`);
+        }
+        if (error instanceof channelService_1.ChannelMemberMutedError) {
+            return (0, errorResponse_1.forbiddenError)(error.message);
+        }
+        if (error instanceof channelService_1.ChannelMessageNotFoundError) {
+            return (0, errorResponse_1.notFoundError)('Message', 'unknown');
+        }
+        if (error instanceof channelService_1.NotMessageAuthorError) {
+            return (0, errorResponse_1.forbiddenError)(error.message);
+        }
+        if (error instanceof channelService_1.ChannelReactionNotFoundError) {
+            return (0, errorResponse_1.notFoundError)('Reaction', 'unknown');
+        }
+        if (error instanceof channelService_1.MemberAlreadyInChannelError) {
+            return {
+                statusCode: 409,
+                response: {
+                    error: {
+                        code: 'ALREADY_EXISTS',
+                        message: error.message,
+                    },
+                },
+            };
+        }
+        if (error instanceof channelService_1.ChannelNameConflictError) {
+            return {
+                statusCode: 409,
+                response: {
+                    error: {
+                        code: 'ALREADY_EXISTS',
+                        message: error.message,
+                    },
+                },
+            };
+        }
+        if (error instanceof channelService_1.ChannelJoinDeniedError) {
+            return (0, errorResponse_1.forbiddenError)(error.message);
+        }
+        if (error instanceof channelService_1.InviteTokenExpiredError) {
+            return {
+                statusCode: 410,
+                response: {
+                    error: {
+                        code: 'GONE',
+                        message: error.message,
+                    },
+                },
+            };
+        }
+        if (error instanceof channelService_1.InviteTokenNotFoundError) {
+            return (0, errorResponse_1.notFoundError)('InviteToken', 'unknown');
+        }
+        if (error instanceof Error) {
+            return (0, errorResponse_1.internalError)(error);
+        }
+        return (0, errorResponse_1.handleError)(error);
+    }
+}
+exports.ChannelController = ChannelController;
+//# sourceMappingURL=channels.js.map