@brightchain/brightchain-api-lib 0.23.21 → 0.24.0

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

@@ -0,0 +1,890 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrightHubConnectionController = 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 connection management operations.
+ *
+ * Provides REST API endpoints for connection lists, categories, hubs,
+ * notes, suggestions, mutual connections, and follow requests.
+ *
+ * @requirements 34.1-34.22
+ */
+class BrightHubConnectionController extends base_1.BaseController {
+    connectionService = null;
+    discoveryService = null;
+    userProfileService = null;
+    constructor(application) {
+        super(application);
+    }
+    setConnectionService(service) {
+        this.connectionService = service;
+    }
+    setDiscoveryService(service) {
+        this.discoveryService = service;
+    }
+    setUserProfileService(service) {
+        this.userProfileService = service;
+    }
+    getConnectionService() {
+        if (!this.connectionService)
+            throw new Error('ConnectionService not initialized');
+        return this.connectionService;
+    }
+    getDiscoveryService() {
+        if (!this.discoveryService)
+            throw new Error('DiscoveryService not initialized');
+        return this.discoveryService;
+    }
+    getUserProfileService() {
+        if (!this.userProfileService)
+            throw new Error('UserProfileService not initialized');
+        return this.userProfileService;
+    }
+    mapConnectionError(error) {
+        switch (error.code) {
+            case brighthub_lib_1.ConnectionServiceErrorCode.ListNotFound:
+            case brighthub_lib_1.ConnectionServiceErrorCode.CategoryNotFound:
+            case brighthub_lib_1.ConnectionServiceErrorCode.HubNotFound:
+            case brighthub_lib_1.ConnectionServiceErrorCode.NoteNotFound:
+                return (0, errorResponse_1.notFoundError)('Resource', 'unknown');
+            case brighthub_lib_1.ConnectionServiceErrorCode.ListNotAuthorized:
+            case brighthub_lib_1.ConnectionServiceErrorCode.CategoryNotAuthorized:
+            case brighthub_lib_1.ConnectionServiceErrorCode.HubNotAuthorized:
+                return (0, errorResponse_1.forbiddenError)(error.message);
+            case brighthub_lib_1.ConnectionServiceErrorCode.ListLimitExceeded:
+            case brighthub_lib_1.ConnectionServiceErrorCode.ListMemberLimitExceeded:
+            case brighthub_lib_1.ConnectionServiceErrorCode.CategoryLimitExceeded:
+            case brighthub_lib_1.ConnectionServiceErrorCode.HubLimitExceeded:
+            case brighthub_lib_1.ConnectionServiceErrorCode.HubMemberLimitExceeded:
+            case brighthub_lib_1.ConnectionServiceErrorCode.PriorityLimitExceeded:
+            case brighthub_lib_1.ConnectionServiceErrorCode.NoteTooLong:
+            case brighthub_lib_1.ConnectionServiceErrorCode.InvalidImportFormat:
+            case brighthub_lib_1.ConnectionServiceErrorCode.ImportRateLimited:
+                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 = [
+            // ── List Management (21.3) ──
+            (0, node_express_suite_1.routeConfig)('post', '/lists', {
+                handlerKey: 'createList',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Create a connection list',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        201: {
+                            schema: 'ConnectionListResponse',
+                            description: 'List created',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('get', '/lists', {
+                handlerKey: 'getUserLists',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: "Get user's connection lists",
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: {
+                            schema: 'ConnectionListsResponse',
+                            description: 'Lists retrieved',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('put', '/lists/:id', {
+                handlerKey: 'updateList',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Update a connection list',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: {
+                            schema: 'ConnectionListResponse',
+                            description: 'List updated',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('delete', '/lists/:id', {
+                handlerKey: 'deleteList',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Delete a connection list',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        204: { schema: 'EmptyResponse', description: 'List deleted' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/lists/:id/members', {
+                handlerKey: 'addMembers',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Add members to a list',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: { schema: 'MessageResponse', description: 'Members added' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('delete', '/lists/:id/members', {
+                handlerKey: 'removeMembers',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Remove members from a list',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: { schema: 'MessageResponse', description: 'Members removed' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('get', '/lists/:id/members', {
+                handlerKey: 'getListMembers',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Get list members',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: {
+                            schema: 'PaginatedResponse',
+                            description: 'Members retrieved',
+                        },
+                    },
+                },
+            }),
+            // ── Additional Endpoints (21.4) ──
+            (0, node_express_suite_1.routeConfig)('get', '/connections/categories', {
+                handlerKey: 'getCategories',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Get connection categories',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: {
+                            schema: 'CategoriesResponse',
+                            description: 'Categories retrieved',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/connections/:id/note', {
+                handlerKey: 'addNote',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Add a note to a connection',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: { schema: 'MessageResponse', description: 'Note added' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('get', '/connections/suggestions', {
+                handlerKey: 'getSuggestions',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Get connection suggestions',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: {
+                            schema: 'SuggestionsResponse',
+                            description: 'Suggestions retrieved',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('get', '/connections/mutual/:userId', {
+                handlerKey: 'getMutualConnections',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Get mutual connections',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: {
+                            schema: 'PaginatedResponse',
+                            description: 'Mutual connections retrieved',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/connections/:id/priority', {
+                handlerKey: 'setPriority',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Set connection priority',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: { schema: 'MessageResponse', description: 'Priority updated' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/connections/:id/quiet', {
+                handlerKey: 'setQuietMode',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Set quiet mode for connection',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: {
+                            schema: 'MessageResponse',
+                            description: 'Quiet mode updated',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/connections/:id/mute/temporary', {
+                handlerKey: 'setTemporaryMute',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Set temporary mute for connection',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: {
+                            schema: 'MessageResponse',
+                            description: 'Temporary mute set',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('get', '/connections/export', {
+                handlerKey: 'exportConnections',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Export connections',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: {
+                            schema: 'ExportResponse',
+                            description: 'Connections exported',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/connections/import', {
+                handlerKey: 'importConnections',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Import connections',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: {
+                            schema: 'ImportResponse',
+                            description: 'Connections imported',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/hubs', {
+                handlerKey: 'createHub',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Create a hub',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        201: { schema: 'HubResponse', description: 'Hub created' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('get', '/hubs', {
+                handlerKey: 'getHubs',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: "Get user's hubs",
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: {
+                            schema: 'HubsResponse',
+                            description: 'Hubs retrieved',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('get', '/connections/:id/insights', {
+                handlerKey: 'getConnectionInsights',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Get connection insights',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: {
+                            schema: 'InsightsResponse',
+                            description: 'Insights retrieved',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('get', '/follow-requests', {
+                handlerKey: 'getFollowRequests',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Get pending follow requests',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: {
+                            schema: 'FollowRequestsResponse',
+                            description: 'Follow requests retrieved',
+                        },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/follow-requests/:id/approve', {
+                handlerKey: 'approveFollowRequest',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Approve a follow request',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: { schema: 'MessageResponse', description: 'Request approved' },
+                    },
+                },
+            }),
+            (0, node_express_suite_1.routeConfig)('post', '/follow-requests/:id/reject', {
+                handlerKey: 'rejectFollowRequest',
+                useAuthentication: false,
+                useCryptoAuthentication: false,
+                openapi: {
+                    summary: 'Reject a follow request',
+                    tags: ['BrightHub Connections'],
+                    responses: {
+                        200: { schema: 'MessageResponse', description: 'Request rejected' },
+                    },
+                },
+            }),
+        ];
+        node_express_suite_1.ControllerRegistry.register('/brighthub', 'BrightHubConnectionController', this.routeDefinitions);
+        this.handlers = {
+            createList: this.handleCreateList.bind(this),
+            getUserLists: this.handleGetUserLists.bind(this),
+            updateList: this.handleUpdateList.bind(this),
+            deleteList: this.handleDeleteList.bind(this),
+            addMembers: this.handleAddMembers.bind(this),
+            removeMembers: this.handleRemoveMembers.bind(this),
+            getListMembers: this.handleGetListMembers.bind(this),
+            getCategories: this.handleGetCategories.bind(this),
+            addNote: this.handleAddNote.bind(this),
+            getSuggestions: this.handleGetSuggestions.bind(this),
+            getMutualConnections: this.handleGetMutualConnections.bind(this),
+            setPriority: this.handleSetPriority.bind(this),
+            setQuietMode: this.handleSetQuietMode.bind(this),
+            setTemporaryMute: this.handleSetTemporaryMute.bind(this),
+            exportConnections: this.handleExportConnections.bind(this),
+            importConnections: this.handleImportConnections.bind(this),
+            createHub: this.handleCreateHub.bind(this),
+            getHubs: this.handleGetHubs.bind(this),
+            getConnectionInsights: this.handleGetConnectionInsights.bind(this),
+            getFollowRequests: this.handleGetFollowRequests.bind(this),
+            approveFollowRequest: this.handleApproveFollowRequest.bind(this),
+            rejectFollowRequest: this.handleRejectFollowRequest.bind(this),
+        };
+    }
+    // ═══════════════════════════════════════════════════════
+    // List Management Handlers (21.3)
+    // ═══════════════════════════════════════════════════════
+    async handleCreateList(req) {
+        try {
+            const { ownerId, name, description, visibility } = req.body;
+            if (!ownerId)
+                return (0, errorResponse_1.validationError)('Missing required field: ownerId');
+            if (!name)
+                return (0, errorResponse_1.validationError)('Missing required field: name');
+            const list = await this.getConnectionService().createList(ownerId, name, {
+                description,
+                visibility: visibility,
+            });
+            return {
+                statusCode: 201,
+                response: { message: 'List created', data: list },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleGetUserLists(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.getConnectionService().getUserLists(userId, options);
+            return {
+                statusCode: 200,
+                response: {
+                    message: 'OK',
+                    data: {
+                        lists: result.items,
+                        cursor: result.cursor,
+                        hasMore: result.hasMore,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleUpdateList(req) {
+        try {
+            const { id } = req.params;
+            const { ownerId, name, description, visibility } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!ownerId)
+                return (0, errorResponse_1.validationError)('Missing required field: ownerId');
+            const updates = {};
+            if (name !== undefined)
+                updates['name'] = name;
+            if (description !== undefined)
+                updates['description'] = description;
+            if (visibility !== undefined)
+                updates['visibility'] = visibility;
+            const list = await this.getConnectionService().updateList(id, ownerId, updates);
+            return {
+                statusCode: 200,
+                response: { message: 'List updated', data: list },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleDeleteList(req) {
+        try {
+            const { id } = req.params;
+            const { ownerId } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!ownerId)
+                return (0, errorResponse_1.validationError)('Missing required field: ownerId');
+            await this.getConnectionService().deleteList(id, ownerId);
+            return { statusCode: 204, response: { message: 'List deleted' } };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleAddMembers(req) {
+        try {
+            const { id } = req.params;
+            const { ownerId, userIds } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!ownerId)
+                return (0, errorResponse_1.validationError)('Missing required field: ownerId');
+            if (!userIds || !Array.isArray(userIds))
+                return (0, errorResponse_1.validationError)('Missing required field: userIds (array)');
+            await this.getConnectionService().addMembersToList(id, ownerId, userIds);
+            return { statusCode: 200, response: { message: 'Members added' } };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleRemoveMembers(req) {
+        try {
+            const { id } = req.params;
+            const { ownerId, userIds } = req.body;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            if (!ownerId)
+                return (0, errorResponse_1.validationError)('Missing required field: ownerId');
+            if (!userIds || !Array.isArray(userIds))
+                return (0, errorResponse_1.validationError)('Missing required field: userIds (array)');
+            await this.getConnectionService().removeMembersFromList(id, ownerId, userIds);
+            return { statusCode: 200, response: { message: 'Members removed' } };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleGetListMembers(req) {
+        try {
+            const { id } = req.params;
+            if (!id)
+                return (0, errorResponse_1.validationError)('Missing required parameter: id');
+            const typedReq = req;
+            const options = this.parsePaginationOptions(typedReq.query);
+            const result = await this.getConnectionService().getListMembers(id, options);
+            return {
+                statusCode: 200,
+                response: { message: 'OK', data: result },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    // ═══════════════════════════════════════════════════════
+    // Additional Endpoint Handlers (21.4)
+    // ═══════════════════════════════════════════════════════
+    async handleGetCategories(req) {
+        try {
+            const typedReq = req;
+            const userId = typedReq.query['userId'];
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required query parameter: userId');
+            const categories = await this.getConnectionService().getDefaultCategories(userId);
+            return {
+                statusCode: 200,
+                response: { message: 'OK', data: categories },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleAddNote(req) {
+        try {
+            const { id } = req.params;
+            const { userId, note } = 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 (!note)
+                return (0, errorResponse_1.validationError)('Missing required field: note');
+            await this.getConnectionService().addNote(userId, id, note);
+            return { statusCode: 200, response: { message: 'Note added' } };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleGetSuggestions(req) {
+        try {
+            const typedReq = req;
+            const userId = typedReq.query['userId'];
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required query parameter: userId');
+            const limit = typedReq.query['limit']
+                ? parseInt(typedReq.query['limit'], 10)
+                : undefined;
+            const cursor = typedReq.query['cursor'];
+            const result = await this.getDiscoveryService().getSuggestions(userId, {
+                limit,
+                cursor,
+            });
+            return {
+                statusCode: 200,
+                response: { message: 'OK', data: result },
+            };
+        }
+        catch (error) {
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleGetMutualConnections(req) {
+        try {
+            const { userId: targetUserId } = req
+                .params;
+            const typedReq = req;
+            const userId = typedReq.query['userId'];
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required query parameter: userId');
+            if (!targetUserId)
+                return (0, errorResponse_1.validationError)('Missing required parameter: userId');
+            const options = this.parsePaginationOptions(typedReq.query);
+            const result = await this.getConnectionService().getMutualConnections(userId, targetUserId, options);
+            return {
+                statusCode: 200,
+                response: { message: 'OK', data: result },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleSetPriority(req) {
+        try {
+            const { id } = req.params;
+            const { userId, isPriority } = 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 (isPriority === undefined)
+                return (0, errorResponse_1.validationError)('Missing required field: isPriority');
+            await this.getConnectionService().setPriority(userId, id, isPriority);
+            return {
+                statusCode: 200,
+                response: { message: isPriority ? 'Priority set' : 'Priority removed' },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleSetQuietMode(req) {
+        try {
+            const { id } = req.params;
+            const { userId, isQuiet } = 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 (isQuiet === undefined)
+                return (0, errorResponse_1.validationError)('Missing required field: isQuiet');
+            await this.getConnectionService().setQuietMode(userId, id, isQuiet);
+            return {
+                statusCode: 200,
+                response: {
+                    message: isQuiet ? 'Quiet mode enabled' : 'Quiet mode disabled',
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleSetTemporaryMute(req) {
+        try {
+            const { id } = req.params;
+            const { userId, duration } = 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 (!duration)
+                return (0, errorResponse_1.validationError)('Missing required field: duration');
+            await this.getConnectionService().setTemporaryMute(userId, id, duration);
+            return { statusCode: 200, response: { message: 'Temporary mute set' } };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleExportConnections(req) {
+        try {
+            const typedReq = req;
+            const userId = typedReq.query['userId'];
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required query parameter: userId');
+            const exportData = await this.getConnectionService().exportConnections(userId);
+            return {
+                statusCode: 200,
+                response: { message: 'OK', data: exportData },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleImportConnections(req) {
+        try {
+            const { userId, data, format } = req.body;
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required field: userId');
+            if (!data)
+                return (0, errorResponse_1.validationError)('Missing required field: data');
+            const result = await this.getConnectionService().importConnections(userId, data, format ?? 'json');
+            return {
+                statusCode: 200,
+                response: {
+                    message: 'Import complete',
+                    data: result,
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleCreateHub(req) {
+        try {
+            const { ownerId, name } = req.body;
+            if (!ownerId)
+                return (0, errorResponse_1.validationError)('Missing required field: ownerId');
+            if (!name)
+                return (0, errorResponse_1.validationError)('Missing required field: name');
+            const hub = await this.getConnectionService().createHub(ownerId, name);
+            return {
+                statusCode: 201,
+                response: {
+                    message: 'Hub created',
+                    data: hub,
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleGetHubs(req) {
+        try {
+            const typedReq = req;
+            const userId = typedReq.query['userId'];
+            if (!userId)
+                return (0, errorResponse_1.validationError)('Missing required query parameter: userId');
+            const result = await this.getConnectionService().getHubs(userId);
+            return {
+                statusCode: 200,
+                response: { message: 'OK', data: result },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.ConnectionServiceError)
+                return this.mapConnectionError(error);
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleGetConnectionInsights(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 period = typedReq.query['period'] || '30d';
+            const insights = await this.getDiscoveryService().getConnectionInsights(userId, id, period);
+            return {
+                statusCode: 200,
+                response: { message: 'OK', data: insights },
+            };
+        }
+        catch (error) {
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleGetFollowRequests(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.getUserProfileService().getFollowRequests(userId, options);
+            return {
+                statusCode: 200,
+                response: { message: 'OK', data: result },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.UserProfileServiceError) {
+                if (error.code === brighthub_lib_1.UserProfileErrorCode.UserNotFound)
+                    return (0, errorResponse_1.notFoundError)('User', 'unknown');
+                return (0, errorResponse_1.validationError)(error.message);
+            }
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleApproveFollowRequest(req) {
+        const { id } = req.params;
+        try {
+            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.getUserProfileService().approveFollowRequest(userId, id);
+            return {
+                statusCode: 200,
+                response: { message: 'Follow request approved' },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.UserProfileServiceError) {
+                if (error.code === brighthub_lib_1.UserProfileErrorCode.FollowRequestNotFound)
+                    return (0, errorResponse_1.notFoundError)('FollowRequest', id);
+                return (0, errorResponse_1.validationError)(error.message);
+            }
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+    async handleRejectFollowRequest(req) {
+        const { id } = req.params;
+        try {
+            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.getUserProfileService().rejectFollowRequest(userId, id);
+            return {
+                statusCode: 200,
+                response: { message: 'Follow request rejected' },
+            };
+        }
+        catch (error) {
+            if (error instanceof brighthub_lib_1.UserProfileServiceError) {
+                if (error.code === brighthub_lib_1.UserProfileErrorCode.FollowRequestNotFound)
+                    return (0, errorResponse_1.notFoundError)('FollowRequest', id);
+                return (0, errorResponse_1.validationError)(error.message);
+            }
+            return (0, errorResponse_1.handleError)(error);
+        }
+    }
+}
+exports.BrightHubConnectionController = BrightHubConnectionController;
+//# sourceMappingURL=connectionController.js.map