@brightchain/brightchain-api-lib 0.23.25 → 0.24.0

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

@@ -0,0 +1,1887 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionService = void 0;
+exports.createConnectionService = createConnectionService;
+const brighthub_lib_1 = require("@brightchain/brighthub-lib");
+const crypto_1 = require("crypto");
+/**
+ * Default pagination limit
+ */
+const DEFAULT_PAGE_LIMIT = 20;
+/**
+ * Maximum pagination limit
+ */
+const MAX_PAGE_LIMIT = 100;
+/**
+ * Connection_Service implementation (list management)
+ * Handles connection lists, membership, and list lifecycle
+ * @see Requirements: 19.1-19.12
+ */
+class ConnectionService {
+    listsCollection;
+    listMembersCollection;
+    userProfilesCollection;
+    categoriesCollection;
+    categoryAssignmentsCollection;
+    notesCollection;
+    followsCollection;
+    metadataCollection;
+    temporaryMutesCollection;
+    hubsCollection;
+    hubMembersCollection;
+    blocksCollection;
+    listFollowersCollection;
+    /** Tracks last import timestamp per user for rate limiting */
+    lastImportTimestamps = new Map();
+    /** Cache for mutual connection counts with TTL of 5 minutes */
+    mutualConnectionCache = new Map();
+    /** TTL for mutual connection cache entries in milliseconds (5 minutes) */
+    static MUTUAL_CACHE_TTL_MS = 5 * 60 * 1000;
+    constructor(application) {
+        this.listsCollection = application.getModel('brighthub_connection_lists');
+        this.listMembersCollection =
+            application.getModel('brighthub_connection_list_members');
+        this.userProfilesCollection = application.getModel('brighthub_user_profiles');
+        this.categoriesCollection = application.getModel('brighthub_connection_categories');
+        this.categoryAssignmentsCollection =
+            application.getModel('brighthub_connection_category_assignments');
+        this.notesCollection = application.getModel('brighthub_connection_notes');
+        this.followsCollection =
+            application.getModel('brighthub_follows');
+        this.metadataCollection = application.getModel('brighthub_connection_metadata');
+        this.temporaryMutesCollection = application.getModel('brighthub_temporary_mutes');
+        this.hubsCollection = application.getModel('brighthub_hubs');
+        this.hubMembersCollection = application.getModel('brighthub_hub_members');
+        this.blocksCollection =
+            application.getModel('brighthub_blocks');
+        this.listFollowersCollection = application.getModel('brighthub_connection_list_followers');
+    }
+    /**
+     * Convert a database record to the API response format
+     */
+    recordToList(record) {
+        return {
+            _id: record._id,
+            ownerId: record.ownerId,
+            name: record.name,
+            description: record.description,
+            visibility: record.visibility,
+            memberCount: record.memberCount,
+            followerCount: record.followerCount,
+            createdAt: record.createdAt,
+            updatedAt: record.updatedAt,
+        };
+    }
+    /**
+     * Convert a user profile record to the API response format
+     */
+    recordToProfile(record) {
+        return {
+            _id: record._id,
+            username: record.username,
+            displayName: record.displayName,
+            bio: record.bio,
+            profilePictureUrl: record.profilePictureUrl,
+            headerImageUrl: record.headerImageUrl,
+            location: record.location,
+            websiteUrl: record.websiteUrl,
+            followerCount: record.followerCount,
+            followingCount: record.followingCount,
+            postCount: record.postCount,
+            isVerified: record.isVerified,
+            isProtected: record.isProtected,
+            approveFollowersMode: record.approveFollowersMode,
+            privacySettings: record.privacySettings,
+            createdAt: record.createdAt,
+        };
+    }
+    /**
+     * Convert a category database record to the API response format
+     */
+    recordToCategory(record) {
+        return {
+            _id: record._id,
+            ownerId: record.ownerId,
+            name: record.name,
+            color: record.color,
+            icon: record.icon,
+            isDefault: record.isDefault,
+            createdAt: record.createdAt,
+        };
+    }
+    /**
+     * Get effective pagination limit
+     */
+    getLimit(options) {
+        const limit = options?.limit ?? DEFAULT_PAGE_LIMIT;
+        return Math.min(Math.max(1, limit), MAX_PAGE_LIMIT);
+    }
+    /**
+     * Validate and retrieve a list, ensuring the caller is the owner
+     */
+    async getOwnedList(listId, ownerId) {
+        const list = await this.listsCollection
+            .findOne({ _id: listId })
+            .exec();
+        if (!list) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.ListNotFound, `List with ID '${listId}' not found`);
+        }
+        if (list.ownerId !== ownerId) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.ListNotAuthorized, 'Not authorized to modify this list');
+        }
+        return list;
+    }
+    // ═══════════════════════════════════════════════════════
+    // List CRUD Operations
+    // ═══════════════════════════════════════════════════════
+    async createList(ownerId, name, options) {
+        // Validate name
+        if (!name || !name.trim()) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.InvalidListName, 'List name cannot be empty');
+        }
+        // Enforce 100 lists per user limit
+        const existingLists = await this.listsCollection
+            .find({ ownerId })
+            .exec();
+        if (existingLists.length >= brighthub_lib_1.MAX_LISTS_PER_USER) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.ListLimitExceeded, `Cannot create more than ${brighthub_lib_1.MAX_LISTS_PER_USER} lists`);
+        }
+        const now = new Date().toISOString();
+        const record = {
+            _id: (0, crypto_1.randomUUID)(),
+            ownerId,
+            name: name.trim(),
+            description: options?.description,
+            visibility: options?.visibility ?? brighthub_lib_1.ConnectionVisibility.Private,
+            memberCount: 0,
+            followerCount: 0,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.listsCollection.create(record);
+        return this.recordToList(record);
+    }
+    async updateList(listId, ownerId, updates) {
+        const list = await this.getOwnedList(listId, ownerId);
+        // Validate name if being updated
+        if (updates.name !== undefined && (!updates.name || !updates.name.trim())) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.InvalidListName, 'List name cannot be empty');
+        }
+        const now = new Date().toISOString();
+        const updateFields = {
+            updatedAt: now,
+        };
+        if (updates.name !== undefined) {
+            updateFields.name = updates.name.trim();
+        }
+        if (updates.description !== undefined) {
+            updateFields.description = updates.description;
+        }
+        if (updates.visibility !== undefined) {
+            updateFields.visibility = updates.visibility;
+        }
+        await this.listsCollection
+            .updateOne({ _id: listId }, updateFields)
+            .exec();
+        // When visibility changes to Private, remove all external followers
+        if (updates.visibility === brighthub_lib_1.ConnectionVisibility.Private &&
+            list.visibility !== brighthub_lib_1.ConnectionVisibility.Private) {
+            await this.removeNonOwnerFollowersOnPrivate(listId, ownerId);
+        }
+        // Return updated list
+        return this.recordToList({
+            ...list,
+            ...updateFields,
+        });
+    }
+    async deleteList(listId, ownerId) {
+        await this.getOwnedList(listId, ownerId);
+        // Cascade: remove all memberships for this list
+        const members = await this.listMembersCollection
+            .find({ listId })
+            .exec();
+        for (const member of members) {
+            await this.listMembersCollection
+                .deleteOne({ _id: member._id })
+                .exec();
+        }
+        // Cascade: remove all followers for this list
+        const followers = await this.listFollowersCollection
+            .find({ listId })
+            .exec();
+        for (const follower of followers) {
+            await this.listFollowersCollection
+                .deleteOne({ _id: follower._id })
+                .exec();
+        }
+        // Delete the list itself
+        await this.listsCollection
+            .deleteOne({ _id: listId })
+            .exec();
+    }
+    // ═══════════════════════════════════════════════════════
+    // List Membership Operations
+    // ═══════════════════════════════════════════════════════
+    async addMembersToList(listId, ownerId, userIds) {
+        const list = await this.getOwnedList(listId, ownerId);
+        if (userIds.length === 0) {
+            return;
+        }
+        // Check member limit
+        const newTotal = list.memberCount + userIds.length;
+        if (newTotal > brighthub_lib_1.MAX_MEMBERS_PER_LIST) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.ListMemberLimitExceeded, `Cannot exceed ${brighthub_lib_1.MAX_MEMBERS_PER_LIST} members per list`);
+        }
+        const now = new Date().toISOString();
+        let addedCount = 0;
+        for (const userId of userIds) {
+            // Check if already a member (skip duplicates)
+            const existing = await this.listMembersCollection
+                .findOne({
+                listId,
+                userId,
+            })
+                .exec();
+            if (!existing) {
+                await this.listMembersCollection.create({
+                    _id: (0, crypto_1.randomUUID)(),
+                    listId,
+                    userId,
+                    addedAt: now,
+                });
+                addedCount++;
+            }
+        }
+        // Update member count
+        if (addedCount > 0) {
+            await this.listsCollection
+                .updateOne({ _id: listId }, {
+                memberCount: list.memberCount + addedCount,
+                updatedAt: now,
+            })
+                .exec();
+        }
+    }
+    async removeMembersFromList(listId, ownerId, userIds) {
+        const list = await this.getOwnedList(listId, ownerId);
+        if (userIds.length === 0) {
+            return;
+        }
+        let removedCount = 0;
+        for (const userId of userIds) {
+            const result = await this.listMembersCollection
+                .deleteOne({
+                listId,
+                userId,
+            })
+                .exec();
+            if (result.deletedCount > 0) {
+                removedCount++;
+            }
+        }
+        // Update member count
+        if (removedCount > 0) {
+            const newCount = Math.max(0, list.memberCount - removedCount);
+            await this.listsCollection
+                .updateOne({ _id: listId }, {
+                memberCount: newCount,
+                updatedAt: new Date().toISOString(),
+            })
+                .exec();
+        }
+    }
+    async getListMembers(listId, options) {
+        // Verify list exists
+        const list = await this.listsCollection
+            .findOne({ _id: listId })
+            .exec();
+        if (!list) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.ListNotFound, `List with ID '${listId}' not found`);
+        }
+        const limit = this.getLimit(options);
+        // Fetch one extra to determine hasMore
+        const queryLimit = limit + 1;
+        let query = this.listMembersCollection.find({
+            listId,
+        });
+        if (query.sort) {
+            query = query.sort({ addedAt: -1 });
+        }
+        // Apply cursor-based pagination (cursor is the addedAt timestamp)
+        const allMembers = await query.exec();
+        let filteredMembers = allMembers;
+        if (options?.cursor) {
+            filteredMembers = allMembers.filter((m) => m.addedAt < options.cursor);
+        }
+        const paginatedMembers = filteredMembers.slice(0, queryLimit);
+        const hasMore = paginatedMembers.length > limit;
+        const resultMembers = hasMore
+            ? paginatedMembers.slice(0, limit)
+            : paginatedMembers;
+        // Look up user profiles for each member
+        const profiles = [];
+        for (const member of resultMembers) {
+            const userRecord = await this.userProfilesCollection
+                .findOne({ _id: member.userId })
+                .exec();
+            if (userRecord) {
+                profiles.push(this.recordToProfile(userRecord));
+            }
+        }
+        const lastMember = resultMembers[resultMembers.length - 1];
+        return {
+            items: profiles,
+            cursor: hasMore && lastMember ? lastMember.addedAt : undefined,
+            hasMore,
+        };
+    }
+    // ═══════════════════════════════════════════════════════
+    // List Query Operations
+    // ═══════════════════════════════════════════════════════
+    async getUserLists(ownerId, options) {
+        const limit = this.getLimit(options);
+        const queryLimit = limit + 1;
+        let query = this.listsCollection.find({
+            ownerId,
+        });
+        if (query.sort) {
+            query = query.sort({ createdAt: -1 });
+        }
+        const allLists = await query.exec();
+        let filteredLists = allLists;
+        if (options?.cursor) {
+            filteredLists = allLists.filter((l) => l.createdAt < options.cursor);
+        }
+        const paginatedLists = filteredLists.slice(0, queryLimit);
+        const hasMore = paginatedLists.length > limit;
+        const resultLists = hasMore
+            ? paginatedLists.slice(0, limit)
+            : paginatedLists;
+        const lastList = resultLists[resultLists.length - 1];
+        return {
+            items: resultLists.map((r) => this.recordToList(r)),
+            cursor: hasMore && lastList ? lastList.createdAt : undefined,
+            hasMore,
+        };
+    }
+    // ═══════════════════════════════════════════════════════
+    // Category Helper Methods
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Validate and retrieve a category, ensuring the caller is the owner
+     */
+    async getOwnedCategory(categoryId, ownerId) {
+        const category = await this.categoriesCollection
+            .findOne({ _id: categoryId })
+            .exec();
+        if (!category) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.CategoryNotFound, `Category with ID '${categoryId}' not found`);
+        }
+        if (category.ownerId !== ownerId) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.CategoryNotAuthorized, 'Not authorized to modify this category');
+        }
+        return category;
+    }
+    // ═══════════════════════════════════════════════════════
+    // Category CRUD Operations (Requirements 20.1-20.8)
+    // ═══════════════════════════════════════════════════════
+    async createCategory(ownerId, name, options) {
+        // Validate name
+        if (!name || !name.trim()) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.InvalidCategoryName, 'Category name cannot be empty');
+        }
+        // Check for duplicate name
+        const existingByName = await this.categoriesCollection
+            .find({ ownerId })
+            .exec();
+        const duplicateName = existingByName.find((c) => c.name.toLowerCase() === name.trim().toLowerCase());
+        if (duplicateName) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.DuplicateCategoryName, `A category named '${name.trim()}' already exists`);
+        }
+        // Enforce 20 custom categories per user limit (default categories don't count)
+        const customCategories = existingByName.filter((c) => !c.isDefault);
+        if (customCategories.length >= brighthub_lib_1.MAX_CATEGORIES_PER_USER) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.CategoryLimitExceeded, `Cannot create more than ${brighthub_lib_1.MAX_CATEGORIES_PER_USER} custom categories`);
+        }
+        const now = new Date().toISOString();
+        const record = {
+            _id: (0, crypto_1.randomUUID)(),
+            ownerId,
+            name: name.trim(),
+            color: options?.color,
+            icon: options?.icon,
+            isDefault: false,
+            createdAt: now,
+        };
+        await this.categoriesCollection.create(record);
+        return this.recordToCategory(record);
+    }
+    async assignCategory(connectionId, categoryId, ownerId) {
+        // Verify category exists and belongs to the owner
+        await this.getOwnedCategory(categoryId, ownerId);
+        // Check if already assigned
+        const existing = await this.categoryAssignmentsCollection
+            .findOne({
+            connectionId,
+            categoryId,
+        })
+            .exec();
+        if (existing) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.CategoryAlreadyAssigned, 'Category is already assigned to this connection');
+        }
+        const now = new Date().toISOString();
+        await this.categoryAssignmentsCollection.create({
+            _id: (0, crypto_1.randomUUID)(),
+            ownerId,
+            connectionId,
+            categoryId,
+            assignedAt: now,
+        });
+    }
+    async unassignCategory(connectionId, categoryId, ownerId) {
+        // Verify category exists and belongs to the owner
+        await this.getOwnedCategory(categoryId, ownerId);
+        const result = await this.categoryAssignmentsCollection
+            .deleteOne({
+            connectionId,
+            categoryId,
+        })
+            .exec();
+        if (result.deletedCount === 0) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.CategoryNotAssigned, 'Category is not assigned to this connection');
+        }
+    }
+    async bulkAssignCategory(connectionIds, categoryId, ownerId) {
+        if (connectionIds.length === 0) {
+            return;
+        }
+        // Verify category exists and belongs to the owner
+        await this.getOwnedCategory(categoryId, ownerId);
+        const now = new Date().toISOString();
+        for (const connectionId of connectionIds) {
+            // Skip if already assigned
+            const existing = await this.categoryAssignmentsCollection
+                .findOne({
+                connectionId,
+                categoryId,
+            })
+                .exec();
+            if (!existing) {
+                await this.categoryAssignmentsCollection.create({
+                    _id: (0, crypto_1.randomUUID)(),
+                    ownerId,
+                    connectionId,
+                    categoryId,
+                    assignedAt: now,
+                });
+            }
+        }
+    }
+    async getConnectionsByCategory(ownerId, categoryId, options) {
+        // Verify category exists and belongs to the owner
+        await this.getOwnedCategory(categoryId, ownerId);
+        const limit = this.getLimit(options);
+        const queryLimit = limit + 1;
+        // Get all assignments for this category
+        let query = this.categoryAssignmentsCollection.find({
+            ownerId,
+            categoryId,
+        });
+        if (query.sort) {
+            query = query.sort({ assignedAt: -1 });
+        }
+        const allAssignments = await query.exec();
+        let filteredAssignments = allAssignments;
+        if (options?.cursor) {
+            filteredAssignments = allAssignments.filter((a) => a.assignedAt < options.cursor);
+        }
+        const paginatedAssignments = filteredAssignments.slice(0, queryLimit);
+        const hasMore = paginatedAssignments.length > limit;
+        const resultAssignments = hasMore
+            ? paginatedAssignments.slice(0, limit)
+            : paginatedAssignments;
+        // Look up user profiles for each connection
+        const profiles = [];
+        for (const assignment of resultAssignments) {
+            const userRecord = await this.userProfilesCollection
+                .findOne({
+                _id: assignment.connectionId,
+            })
+                .exec();
+            if (userRecord) {
+                profiles.push(this.recordToProfile(userRecord));
+            }
+        }
+        const lastAssignment = resultAssignments[resultAssignments.length - 1];
+        return {
+            items: profiles,
+            cursor: hasMore && lastAssignment ? lastAssignment.assignedAt : undefined,
+            hasMore,
+        };
+    }
+    async deleteCategory(categoryId, ownerId) {
+        const category = await this.getOwnedCategory(categoryId, ownerId);
+        // Prevent deleting default categories
+        if (category.isDefault) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.CannotDeleteDefaultCategory, 'Cannot delete a default category');
+        }
+        // Remove all assignments for this category
+        const assignments = await this.categoryAssignmentsCollection
+            .find({ categoryId })
+            .exec();
+        for (const assignment of assignments) {
+            await this.categoryAssignmentsCollection
+                .deleteOne({
+                _id: assignment._id,
+            })
+                .exec();
+        }
+        // Delete the category itself
+        await this.categoriesCollection
+            .deleteOne({ _id: categoryId })
+            .exec();
+    }
+    async getDefaultCategories(ownerId) {
+        // Check if default categories already exist for this user
+        const existingCategories = await this.categoriesCollection
+            .find({ ownerId, isDefault: true })
+            .exec();
+        if (existingCategories.length > 0) {
+            return existingCategories.map((r) => this.recordToCategory(r));
+        }
+        // Create default categories
+        const now = new Date().toISOString();
+        const created = [];
+        for (const def of brighthub_lib_1.DEFAULT_CONNECTION_CATEGORIES) {
+            const record = {
+                _id: (0, crypto_1.randomUUID)(),
+                ownerId,
+                name: def.name,
+                color: def.color,
+                icon: def.icon,
+                isDefault: true,
+                createdAt: now,
+            };
+            await this.categoriesCollection.create(record);
+            created.push(this.recordToCategory(record));
+        }
+        return created;
+    }
+    // ═══════════════════════════════════════════════════════
+    // Connection Note Operations (Requirements 21.1-21.7)
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Validate note content
+     * @throws ConnectionServiceError if note is empty or exceeds limit
+     */
+    validateNoteContent(note) {
+        if (!note || !note.trim()) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.InvalidNoteContent, 'Note content cannot be empty');
+        }
+        if (note.length > brighthub_lib_1.MAX_NOTE_LENGTH) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.NoteTooLong, `Note cannot exceed ${brighthub_lib_1.MAX_NOTE_LENGTH} characters`);
+        }
+    }
+    /**
+     * Convert a note record to the API response format
+     */
+    recordToNote(record) {
+        return {
+            _id: record._id,
+            userId: record.userId,
+            connectionId: record.connectionId,
+            note: record.note,
+            createdAt: record.createdAt,
+            updatedAt: record.updatedAt,
+        };
+    }
+    async addNote(userId, connectionId, note) {
+        this.validateNoteContent(note);
+        // Check if a note already exists for this connection (unique constraint)
+        const existing = await this.notesCollection
+            .findOne({
+            userId,
+            connectionId,
+        })
+            .exec();
+        if (existing) {
+            // Update existing note instead of creating duplicate
+            const now = new Date().toISOString();
+            await this.notesCollection
+                .updateOne({ _id: existing._id }, {
+                note: note.trim(),
+                updatedAt: now,
+            })
+                .exec();
+            return this.recordToNote({
+                ...existing,
+                note: note.trim(),
+                updatedAt: now,
+            });
+        }
+        const now = new Date().toISOString();
+        const record = {
+            _id: (0, crypto_1.randomUUID)(),
+            userId,
+            connectionId,
+            note: note.trim(),
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.notesCollection.create(record);
+        return this.recordToNote(record);
+    }
+    async updateNote(userId, connectionId, note) {
+        this.validateNoteContent(note);
+        const existing = await this.notesCollection
+            .findOne({
+            userId,
+            connectionId,
+        })
+            .exec();
+        if (!existing) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.NoteNotFound, 'No note found for this connection');
+        }
+        const now = new Date().toISOString();
+        await this.notesCollection
+            .updateOne({ _id: existing._id }, {
+            note: note.trim(),
+            updatedAt: now,
+        })
+            .exec();
+        return this.recordToNote({
+            ...existing,
+            note: note.trim(),
+            updatedAt: now,
+        });
+    }
+    async deleteNote(userId, connectionId) {
+        const result = await this.notesCollection
+            .deleteOne({
+            userId,
+            connectionId,
+        })
+            .exec();
+        if (result.deletedCount === 0) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.NoteNotFound, 'No note found for this connection');
+        }
+    }
+    async searchConnectionsByNote(userId, searchTerm, options) {
+        const limit = this.getLimit(options);
+        const skip = options?.cursor ? parseInt(options.cursor, 10) : 0;
+        // Find all notes for this user (we filter in-memory for text matching
+        // since the mock collection doesn't support regex/text search)
+        const allNotes = await this.notesCollection
+            .find({ userId })
+            .exec();
+        // Filter by search term (case-insensitive)
+        const searchLower = searchTerm.toLowerCase();
+        const matchingNotes = allNotes.filter((n) => n.note.toLowerCase().includes(searchLower));
+        // Apply pagination
+        const paginatedNotes = matchingNotes.slice(skip, skip + limit + 1);
+        const hasMore = paginatedNotes.length > limit;
+        const results = paginatedNotes.slice(0, limit);
+        return {
+            items: results.map((r) => this.recordToNote(r)),
+            cursor: hasMore ? String(skip + limit) : undefined,
+            hasMore,
+        };
+    }
+    // ═══════════════════════════════════════════════════════
+    // Import/Export Operations (Requirements 22.1-22.7)
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Check and enforce rate limiting for import operations
+     * @throws ConnectionServiceError if rate limited
+     */
+    checkImportRateLimit(userId) {
+        const lastImport = this.lastImportTimestamps.get(userId);
+        if (lastImport !== undefined) {
+            const elapsed = Date.now() - lastImport;
+            if (elapsed < brighthub_lib_1.IMPORT_RATE_LIMIT_MS) {
+                throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.ImportRateLimited, `Import rate limited. Please wait ${Math.ceil((brighthub_lib_1.IMPORT_RATE_LIMIT_MS - elapsed) / 1000)} seconds before importing again.`);
+            }
+        }
+    }
+    /**
+     * Parse CSV data into an array of usernames (one per line)
+     */
+    parseCsvUsernames(data) {
+        return data
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0 && !line.startsWith('#'));
+    }
+    /**
+     * Look up a user profile by username
+     */
+    async findUserByUsername(username) {
+        return this.userProfilesCollection
+            .findOne({ username })
+            .exec();
+    }
+    async exportConnections(userId) {
+        // Get all follows for this user
+        const follows = await this.followsCollection
+            .find({ followerId: userId })
+            .exec();
+        const followedIds = follows.map((f) => f.followedId);
+        // Get all category assignments for this user
+        const allAssignments = await this.categoryAssignmentsCollection
+            .find({ ownerId: userId })
+            .exec();
+        // Get all categories for this user
+        const allCategories = await this.categoriesCollection
+            .find({ ownerId: userId })
+            .exec();
+        const categoryMap = new Map(allCategories.map((c) => [c._id, c.name]));
+        // Get all notes for this user
+        const allNotes = await this.notesCollection
+            .find({ userId })
+            .exec();
+        const noteMap = new Map(allNotes.map((n) => [n.connectionId, n.note]));
+        // Get all list memberships for lists owned by this user
+        const userLists = await this.listsCollection
+            .find({ ownerId: userId })
+            .exec();
+        const listNameMap = new Map(userLists.map((l) => [l._id, l.name]));
+        // Build a map of connectionId -> list names
+        const connectionListNames = new Map();
+        for (const list of userLists) {
+            const members = await this.listMembersCollection
+                .find({ listId: list._id })
+                .exec();
+            for (const member of members) {
+                const existing = connectionListNames.get(member.userId) || [];
+                const listName = listNameMap.get(list._id);
+                if (listName) {
+                    existing.push(listName);
+                }
+                connectionListNames.set(member.userId, existing);
+            }
+        }
+        // Build connection entries
+        const connections = [];
+        for (const followedId of followedIds) {
+            const profile = await this.userProfilesCollection
+                .findOne({ _id: followedId })
+                .exec();
+            if (!profile)
+                continue;
+            // Get categories for this connection
+            const assignments = allAssignments.filter((a) => a.connectionId === followedId);
+            const categories = assignments
+                .map((a) => categoryMap.get(a.categoryId))
+                .filter((name) => name !== undefined);
+            connections.push({
+                username: profile.username,
+                displayName: profile.displayName,
+                categories,
+                note: noteMap.get(followedId),
+                lists: connectionListNames.get(followedId) || [],
+            });
+        }
+        return {
+            version: '1.0',
+            exportedAt: new Date().toISOString(),
+            userId,
+            connectionCount: connections.length,
+            connections,
+        };
+    }
+    async exportList(listId, ownerId) {
+        const list = await this.getOwnedList(listId, ownerId);
+        // Get all members
+        const memberRecords = await this.listMembersCollection
+            .find({ listId })
+            .exec();
+        const members = [];
+        for (const memberRecord of memberRecords) {
+            const profile = await this.userProfilesCollection
+                .findOne({ _id: memberRecord.userId })
+                .exec();
+            if (profile) {
+                members.push({
+                    username: profile.username,
+                    displayName: profile.displayName,
+                });
+            }
+        }
+        return {
+            version: '1.0',
+            exportedAt: new Date().toISOString(),
+            listName: list.name,
+            description: list.description,
+            visibility: list.visibility,
+            memberCount: members.length,
+            members,
+        };
+    }
+    async importConnections(userId, data, format) {
+        this.checkImportRateLimit(userId);
+        let usernames;
+        if (format === 'csv') {
+            usernames = this.parseCsvUsernames(data);
+        }
+        else {
+            try {
+                const parsed = JSON.parse(data);
+                if (parsed.connections && Array.isArray(parsed.connections)) {
+                    usernames = parsed.connections
+                        .map((c) => c.username || '')
+                        .filter((u) => u.length > 0);
+                }
+                else if (Array.isArray(parsed)) {
+                    usernames = parsed
+                        .map((entry) => typeof entry === 'string' ? entry : entry.username || '')
+                        .filter((u) => u.length > 0);
+                }
+                else {
+                    throw new Error('Unrecognized JSON structure');
+                }
+            }
+            catch {
+                throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.InvalidImportFormat, 'Invalid JSON format. Expected { connections: [{ username }] } or an array of usernames.');
+            }
+        }
+        // Deduplicate
+        const uniqueUsernames = [...new Set(usernames)];
+        const result = {
+            successCount: 0,
+            skippedCount: 0,
+            totalCount: uniqueUsernames.length,
+            skippedUsernames: [],
+            errors: [],
+        };
+        for (const username of uniqueUsernames) {
+            const profile = await this.findUserByUsername(username);
+            if (!profile) {
+                result.skippedCount++;
+                result.skippedUsernames.push(username);
+                continue;
+            }
+            // Don't follow yourself
+            if (profile._id === userId) {
+                result.skippedCount++;
+                result.errors.push(`Cannot follow yourself (${username})`);
+                continue;
+            }
+            // Skip blocked users (Requirement 32.5)
+            const isBlocked = await this.isBlockedFromList(profile._id, userId);
+            const isBlockedBy = await this.blocksCollection
+                .findOne({
+                blockerId: profile._id,
+                blockedId: userId,
+            })
+                .exec();
+            if (isBlocked || isBlockedBy) {
+                result.skippedCount++;
+                result.errors.push(`Skipped blocked user: ${username}`);
+                continue;
+            }
+            // Check if already following
+            const existingFollow = await this.followsCollection
+                .findOne({
+                followerId: userId,
+                followedId: profile._id,
+            })
+                .exec();
+            if (existingFollow) {
+                // Already following, count as success (idempotent)
+                result.successCount++;
+                continue;
+            }
+            // Create follow relationship
+            await this.followsCollection.create({
+                _id: (0, crypto_1.randomUUID)(),
+                followerId: userId,
+                followedId: profile._id,
+                createdAt: new Date().toISOString(),
+            });
+            result.successCount++;
+        }
+        // Record import timestamp for rate limiting
+        this.lastImportTimestamps.set(userId, Date.now());
+        return result;
+    }
+    async importList(userId, data, format) {
+        this.checkImportRateLimit(userId);
+        let listName;
+        let description;
+        let visibility = brighthub_lib_1.ConnectionVisibility.Private;
+        let usernames;
+        if (format === 'csv') {
+            // CSV: first line is list name, rest are usernames
+            const lines = data
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0 && !line.startsWith('#'));
+            if (lines.length === 0) {
+                throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.InvalidImportFormat, 'CSV data is empty. Expected at least a list name on the first line.');
+            }
+            listName = lines[0];
+            usernames = lines.slice(1);
+        }
+        else {
+            try {
+                const parsed = JSON.parse(data);
+                listName = parsed.listName || parsed.name;
+                if (!listName || typeof listName !== 'string') {
+                    throw new Error('Missing list name');
+                }
+                description = parsed.description;
+                if (parsed.visibility &&
+                    Object.values(brighthub_lib_1.ConnectionVisibility).includes(parsed.visibility)) {
+                    visibility = parsed.visibility;
+                }
+                if (parsed.members && Array.isArray(parsed.members)) {
+                    usernames = parsed.members
+                        .map((m) => typeof m === 'string' ? m : m.username || '')
+                        .filter((u) => u.length > 0);
+                }
+                else {
+                    usernames = [];
+                }
+            }
+            catch {
+                throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.InvalidImportFormat, 'Invalid JSON format. Expected { listName, members: [{ username }] }.');
+            }
+        }
+        // Create the list
+        const list = await this.createList(userId, listName, {
+            description,
+            visibility,
+        });
+        // Deduplicate
+        const uniqueUsernames = [...new Set(usernames)];
+        const result = {
+            successCount: 0,
+            skippedCount: 0,
+            totalCount: uniqueUsernames.length,
+            skippedUsernames: [],
+            errors: [],
+        };
+        const validUserIds = [];
+        for (const username of uniqueUsernames) {
+            const profile = await this.findUserByUsername(username);
+            if (!profile) {
+                result.skippedCount++;
+                result.skippedUsernames.push(username);
+                continue;
+            }
+            // Skip blocked users during list import (Requirement 32.5)
+            const isBlocked = await this.isBlockedFromList(profile._id, userId);
+            if (isBlocked) {
+                result.skippedCount++;
+                result.errors.push(`Skipped blocked user: ${username}`);
+                continue;
+            }
+            // Check if this user is a connection (followed by the importer)
+            const existingFollow = await this.followsCollection
+                .findOne({
+                followerId: userId,
+                followedId: profile._id,
+            })
+                .exec();
+            if (!existingFollow) {
+                result.skippedCount++;
+                result.errors.push(`${username} is not a connection; only existing connections can be added to lists`);
+                continue;
+            }
+            validUserIds.push(profile._id);
+            result.successCount++;
+        }
+        // Add valid users to the list in bulk
+        if (validUserIds.length > 0) {
+            await this.addMembersToList(list._id, userId, validUserIds);
+        }
+        // Record import timestamp for rate limiting
+        this.lastImportTimestamps.set(userId, Date.now());
+        return result;
+    }
+    // ═══════════════════════════════════════════════════════
+    // Priority Connection Operations (Requirements 23.1-23.5)
+    // ═══════════════════════════════════════════════════════
+    async setPriority(userId, connectionId, isPriority) {
+        // If setting priority=true, enforce the 50 limit
+        if (isPriority) {
+            const allMetadata = await this.metadataCollection
+                .find({ userId, isPriority: true })
+                .exec();
+            // Check if this connection is already priority (don't count it against the limit)
+            const existingForConnection = allMetadata.find((m) => m.connectionId === connectionId);
+            const currentPriorityCount = allMetadata.length;
+            if (!existingForConnection?.isPriority &&
+                currentPriorityCount >= brighthub_lib_1.MAX_PRIORITY_CONNECTIONS) {
+                throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.PriorityLimitExceeded, `Cannot have more than ${brighthub_lib_1.MAX_PRIORITY_CONNECTIONS} priority connections`);
+            }
+        }
+        // Check if metadata record already exists for this user+connection
+        const existing = await this.metadataCollection
+            .findOne({
+            userId,
+            connectionId,
+        })
+            .exec();
+        const now = new Date().toISOString();
+        if (existing) {
+            // Update existing record
+            await this.metadataCollection
+                .updateOne({ _id: existing._id }, {
+                isPriority,
+                updatedAt: now,
+            })
+                .exec();
+        }
+        else {
+            // Create new metadata record (upsert)
+            await this.metadataCollection.create({
+                _id: (0, crypto_1.randomUUID)(),
+                userId,
+                connectionId,
+                isPriority,
+                isQuiet: false,
+                createdAt: now,
+                updatedAt: now,
+            });
+        }
+    }
+    async getPriorityConnections(userId, options) {
+        const limit = this.getLimit(options);
+        const queryLimit = limit + 1;
+        // Get all priority metadata records for this user
+        let query = this.metadataCollection.find({
+            userId,
+            isPriority: true,
+        });
+        if (query.sort) {
+            query = query.sort({ updatedAt: -1 });
+        }
+        const allRecords = await query.exec();
+        let filteredRecords = allRecords;
+        if (options?.cursor) {
+            filteredRecords = allRecords.filter((r) => r.updatedAt < options.cursor);
+        }
+        const paginatedRecords = filteredRecords.slice(0, queryLimit);
+        const hasMore = paginatedRecords.length > limit;
+        const resultRecords = hasMore
+            ? paginatedRecords.slice(0, limit)
+            : paginatedRecords;
+        // Look up user profiles for each priority connection
+        const profiles = [];
+        for (const record of resultRecords) {
+            const userRecord = await this.userProfilesCollection
+                .findOne({
+                _id: record.connectionId,
+            })
+                .exec();
+            if (userRecord) {
+                profiles.push(this.recordToProfile(userRecord));
+            }
+        }
+        const lastRecord = resultRecords[resultRecords.length - 1];
+        return {
+            items: profiles,
+            cursor: hasMore && lastRecord ? lastRecord.updatedAt : undefined,
+            hasMore,
+        };
+    }
+    async setQuietMode(userId, connectionId, isQuiet) {
+        // Check if metadata record already exists for this user+connection
+        const existing = await this.metadataCollection
+            .findOne({
+            userId,
+            connectionId,
+        })
+            .exec();
+        const now = new Date().toISOString();
+        if (existing) {
+            // Update existing record
+            await this.metadataCollection
+                .updateOne({ _id: existing._id }, {
+                isQuiet,
+                updatedAt: now,
+            })
+                .exec();
+        }
+        else {
+            // Create new metadata record (upsert)
+            await this.metadataCollection.create({
+                _id: (0, crypto_1.randomUUID)(),
+                userId,
+                connectionId,
+                isPriority: false,
+                isQuiet,
+                createdAt: now,
+                updatedAt: now,
+            });
+        }
+    }
+    async getQuietConnections(userId, options) {
+        const limit = this.getLimit(options);
+        const queryLimit = limit + 1;
+        // Get all quiet metadata records for this user
+        let query = this.metadataCollection.find({
+            userId,
+            isQuiet: true,
+        });
+        if (query.sort) {
+            query = query.sort({ updatedAt: -1 });
+        }
+        const allRecords = await query.exec();
+        let filteredRecords = allRecords;
+        if (options?.cursor) {
+            filteredRecords = allRecords.filter((r) => r.updatedAt < options.cursor);
+        }
+        const paginatedRecords = filteredRecords.slice(0, queryLimit);
+        const hasMore = paginatedRecords.length > limit;
+        const resultRecords = hasMore
+            ? paginatedRecords.slice(0, limit)
+            : paginatedRecords;
+        // Look up user profiles for each quiet connection
+        const profiles = [];
+        for (const record of resultRecords) {
+            const userRecord = await this.userProfilesCollection
+                .findOne({
+                _id: record.connectionId,
+            })
+                .exec();
+            if (userRecord) {
+                profiles.push(this.recordToProfile(userRecord));
+            }
+        }
+        const lastRecord = resultRecords[resultRecords.length - 1];
+        return {
+            items: profiles,
+            cursor: hasMore && lastRecord ? lastRecord.updatedAt : undefined,
+            hasMore,
+        };
+    }
+    /**
+     * Calculate the expiration date for a mute duration.
+     * @param duration The mute duration
+     * @returns ISO string of the expiration date
+     */
+    calculateExpiresAt(duration) {
+        const durationToMs = {
+            '1h': 3600000,
+            '8h': 28800000,
+            '24h': 86400000,
+            '7d': 604800000,
+            '30d': 2592000000,
+            // ~100 years for permanent mutes
+            permanent: 100 * 365.25 * 24 * 60 * 60 * 1000,
+        };
+        const ms = durationToMs[duration];
+        return new Date(Date.now() + ms).toISOString();
+    }
+    /**
+     * Set a temporary mute on a connection with a specified duration.
+     * Creates or updates a mute record with a calculated expiration timestamp.
+     * @see Requirements: 25.1, 25.2
+     */
+    async setTemporaryMute(userId, connectionId, duration) {
+        const now = new Date().toISOString();
+        const expiresAt = this.calculateExpiresAt(duration);
+        // Check if a mute already exists for this user+connection
+        const existing = await this.temporaryMutesCollection
+            .findOne({
+            userId,
+            connectionId,
+        })
+            .exec();
+        if (existing) {
+            // Update existing mute with new duration and expiration
+            await this.temporaryMutesCollection
+                .updateOne({ _id: existing._id }, {
+                duration,
+                expiresAt,
+                createdAt: now,
+            })
+                .exec();
+        }
+        else {
+            // Create new mute record
+            await this.temporaryMutesCollection.create({
+                _id: (0, crypto_1.randomUUID)(),
+                userId,
+                connectionId,
+                duration,
+                expiresAt,
+                createdAt: now,
+            });
+        }
+    }
+    /**
+     * Remove a temporary mute before it expires (early unmute).
+     * @see Requirements: 25.7
+     */
+    async removeTemporaryMute(userId, connectionId) {
+        await this.temporaryMutesCollection
+            .deleteOne({
+            userId,
+            connectionId,
+        })
+            .exec();
+    }
+    /**
+     * Convert a temporary mute to a permanent mute.
+     * @see Requirements: 25.6
+     */
+    async convertToPermanentMute(userId, connectionId) {
+        const existing = await this.temporaryMutesCollection
+            .findOne({
+            userId,
+            connectionId,
+        })
+            .exec();
+        if (!existing) {
+            // No existing mute — create a permanent one
+            await this.setTemporaryMute(userId, connectionId, brighthub_lib_1.MuteDuration.Permanent);
+            return;
+        }
+        const permanentExpiresAt = this.calculateExpiresAt(brighthub_lib_1.MuteDuration.Permanent);
+        await this.temporaryMutesCollection
+            .updateOne({ _id: existing._id }, {
+            duration: brighthub_lib_1.MuteDuration.Permanent,
+            expiresAt: permanentExpiresAt,
+        })
+            .exec();
+    }
+    /**
+     * Get all muted connections for a user with their expiration info.
+     * Only returns currently active (non-expired) mutes.
+     * @see Requirements: 25.5
+     */
+    async getMutedConnections(userId, options) {
+        const limit = this.getLimit(options);
+        const queryLimit = limit + 1;
+        const now = new Date().toISOString();
+        // Get all mute records for this user
+        let query = this.temporaryMutesCollection.find({
+            userId,
+        });
+        if (query.sort) {
+            query = query.sort({ expiresAt: 1 });
+        }
+        const allRecords = await query.exec();
+        // Filter to only active (non-expired) mutes
+        let filteredRecords = allRecords.filter((r) => r.expiresAt > now);
+        // Apply cursor-based pagination
+        if (options?.cursor) {
+            filteredRecords = filteredRecords.filter((r) => r.expiresAt > options.cursor);
+        }
+        const paginatedRecords = filteredRecords.slice(0, queryLimit);
+        const hasMore = paginatedRecords.length > limit;
+        const resultRecords = hasMore
+            ? paginatedRecords.slice(0, limit)
+            : paginatedRecords;
+        // Look up user profiles and attach mute info
+        const results = [];
+        for (const record of resultRecords) {
+            const userRecord = await this.userProfilesCollection
+                .findOne({
+                _id: record.connectionId,
+            })
+                .exec();
+            if (userRecord) {
+                results.push({
+                    ...this.recordToProfile(userRecord),
+                    expiresAt: record.expiresAt,
+                    duration: record.duration,
+                });
+            }
+        }
+        const lastRecord = resultRecords[resultRecords.length - 1];
+        return {
+            items: results,
+            cursor: hasMore && lastRecord ? lastRecord.expiresAt : undefined,
+            hasMore,
+        };
+    }
+    // ═══════════════════════════════════════════════════════
+    // Hub Operations (Requirements 30.1-30.10)
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Convert a hub database record to the API response format
+     */
+    recordToHub(record) {
+        return {
+            _id: record._id,
+            ownerId: record.ownerId,
+            name: record.name,
+            memberCount: record.memberCount,
+            isDefault: record.isDefault,
+            createdAt: record.createdAt,
+        };
+    }
+    /**
+     * Validate hub name
+     */
+    validateHubName(name) {
+        if (!name || name.trim().length === 0) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.InvalidHubName, 'Hub name cannot be empty');
+        }
+        if (name.trim().length > 50) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.InvalidHubName, 'Hub name cannot exceed 50 characters');
+        }
+    }
+    /**
+     * Get an owned hub or throw
+     */
+    async getOwnedHub(hubId, ownerId) {
+        const hub = await this.hubsCollection
+            .findOne({ _id: hubId })
+            .exec();
+        if (!hub) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.HubNotFound, `Hub ${hubId} not found`);
+        }
+        if (hub.ownerId !== ownerId) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.HubNotAuthorized, 'Not authorized to modify this hub');
+        }
+        return hub;
+    }
+    /**
+     * Create a new hub
+     * @see Requirements: 30.1, 30.9
+     */
+    async createHub(ownerId, name) {
+        this.validateHubName(name);
+        // Check hub limit
+        const existingHubs = await this.hubsCollection
+            .find({ ownerId })
+            .exec();
+        if (existingHubs.length >= brighthub_lib_1.MAX_HUBS_PER_USER) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.HubLimitExceeded, `Cannot create more than ${brighthub_lib_1.MAX_HUBS_PER_USER} hubs`);
+        }
+        const now = new Date().toISOString();
+        const record = {
+            _id: (0, crypto_1.randomUUID)(),
+            ownerId,
+            name: name.trim(),
+            memberCount: 0,
+            isDefault: false,
+            createdAt: now,
+        };
+        const created = await this.hubsCollection.create(record);
+        return this.recordToHub(created);
+    }
+    /**
+     * Delete a hub and all its memberships.
+     * Cannot delete the default "Close Friends" hub.
+     * @see Requirements: 30.1
+     */
+    async deleteHub(hubId, ownerId) {
+        const hub = await this.getOwnedHub(hubId, ownerId);
+        if (hub.isDefault) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.CannotDeleteDefaultHub, 'Cannot delete the default hub');
+        }
+        // Delete all memberships
+        const members = await this.hubMembersCollection
+            .find({ hubId })
+            .exec();
+        for (const member of members) {
+            await this.hubMembersCollection
+                .deleteOne({ _id: member._id })
+                .exec();
+        }
+        // Delete the hub
+        await this.hubsCollection
+            .deleteOne({ _id: hubId })
+            .exec();
+    }
+    /**
+     * Add members to a hub (bulk support)
+     * @see Requirements: 30.2, 30.10
+     */
+    async addToHub(hubId, ownerId, userIds) {
+        const hub = await this.getOwnedHub(hubId, ownerId);
+        if (hub.memberCount + userIds.length > brighthub_lib_1.MAX_MEMBERS_PER_HUB) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.HubMemberLimitExceeded, `Cannot exceed ${brighthub_lib_1.MAX_MEMBERS_PER_HUB} members per hub`);
+        }
+        const now = new Date().toISOString();
+        let addedCount = 0;
+        for (const userId of userIds) {
+            // Check if already a member
+            const existing = await this.hubMembersCollection
+                .findOne({
+                hubId,
+                userId,
+            })
+                .exec();
+            if (existing) {
+                // Skip duplicates silently for bulk operations
+                continue;
+            }
+            await this.hubMembersCollection.create({
+                _id: (0, crypto_1.randomUUID)(),
+                hubId,
+                userId,
+                addedAt: now,
+            });
+            addedCount++;
+        }
+        // Update member count
+        if (addedCount > 0) {
+            await this.hubsCollection
+                .updateOne({ _id: hubId }, {
+                memberCount: hub.memberCount + addedCount,
+            })
+                .exec();
+        }
+    }
+    /**
+     * Remove members from a hub (bulk support)
+     * @see Requirements: 30.2
+     */
+    async removeFromHub(hubId, ownerId, userIds) {
+        const hub = await this.getOwnedHub(hubId, ownerId);
+        let removedCount = 0;
+        for (const userId of userIds) {
+            const result = await this.hubMembersCollection
+                .deleteOne({
+                hubId,
+                userId,
+            })
+                .exec();
+            if (result.deletedCount > 0) {
+                removedCount++;
+            }
+        }
+        // Update member count
+        if (removedCount > 0) {
+            const newCount = Math.max(0, hub.memberCount - removedCount);
+            await this.hubsCollection
+                .updateOne({ _id: hubId }, { memberCount: newCount })
+                .exec();
+        }
+    }
+    /**
+     * Get all hubs owned by a user
+     * @see Requirements: 30.1
+     */
+    async getHubs(ownerId) {
+        const records = await this.hubsCollection
+            .find({ ownerId })
+            .exec();
+        return records.map((r) => this.recordToHub(r));
+    }
+    /**
+     * Get members of a hub with pagination
+     * @see Requirements: 30.2
+     */
+    async getHubMembers(hubId, options) {
+        const limit = this.getLimit(options);
+        let query = this.hubMembersCollection.find({
+            hubId,
+        });
+        if (options?.cursor && query.sort) {
+            // Use cursor-based pagination by filtering addedAt
+            query = this.hubMembersCollection.find({
+                hubId,
+            });
+        }
+        if (query.sort) {
+            query = query.sort({ addedAt: -1 });
+        }
+        if (query.skip && options?.cursor) {
+            // Simple offset approach: count records before cursor
+        }
+        if (query.limit) {
+            query = query.limit(limit + 1);
+        }
+        const memberRecords = await query.exec();
+        // Filter by cursor if provided
+        const filteredRecords = options?.cursor
+            ? memberRecords.filter((r) => r.addedAt < options.cursor)
+            : memberRecords;
+        const hasMore = filteredRecords.length > limit;
+        const resultRecords = hasMore
+            ? filteredRecords.slice(0, limit)
+            : filteredRecords;
+        // Look up user profiles
+        const results = [];
+        for (const record of resultRecords) {
+            const userRecord = await this.userProfilesCollection
+                .findOne({ _id: record.userId })
+                .exec();
+            if (userRecord) {
+                results.push(this.recordToProfile(userRecord));
+            }
+        }
+        const lastRecord = resultRecords[resultRecords.length - 1];
+        return {
+            items: results,
+            cursor: hasMore && lastRecord ? lastRecord.addedAt : undefined,
+            hasMore,
+        };
+    }
+    /**
+     * Get or create the default "Close Friends" hub for a user
+     * @see Requirements: 30.6
+     */
+    async getOrCreateDefaultHub(ownerId) {
+        // Try to find existing default hub
+        const existing = await this.hubsCollection
+            .findOne({
+            ownerId,
+            isDefault: true,
+        })
+            .exec();
+        if (existing) {
+            return this.recordToHub(existing);
+        }
+        // Create the default hub
+        const now = new Date().toISOString();
+        const record = {
+            _id: (0, crypto_1.randomUUID)(),
+            ownerId,
+            name: brighthub_lib_1.DEFAULT_HUB_NAME,
+            memberCount: 0,
+            isDefault: true,
+            createdAt: now,
+        };
+        const created = await this.hubsCollection.create(record);
+        return this.recordToHub(created);
+    }
+    // ── Mutual Connections ──────────────────────────────────────────────
+    /**
+     * Build a sorted cache key so that (A,B) and (B,A) share the same entry.
+     */
+    mutualCacheKey(userId, otherUserId) {
+        return [userId, otherUserId].sort().join(':');
+    }
+    /**
+     * Get the set of user IDs that a given user follows.
+     */
+    async getFollowedIds(userId) {
+        const follows = await this.followsCollection
+            .find({ followerId: userId })
+            .exec();
+        return new Set(follows.map((f) => f.followedId));
+    }
+    /**
+     * Get mutual connections between two users with pagination.
+     * Mutual connections are users that both userId AND otherUserId follow.
+     * @see Requirements: 28.1, 28.2
+     */
+    async getMutualConnections(userId, otherUserId, options) {
+        const limit = this.getLimit(options);
+        // Get follows for both users
+        const [userFollows, otherFollows] = await Promise.all([
+            this.getFollowedIds(userId),
+            this.getFollowedIds(otherUserId),
+        ]);
+        // Compute intersection
+        const mutualIds = [];
+        for (const id of userFollows) {
+            if (otherFollows.has(id)) {
+                mutualIds.push(id);
+            }
+        }
+        // Sort for deterministic pagination
+        mutualIds.sort();
+        // Apply cursor-based pagination
+        let startIndex = 0;
+        if (options?.cursor) {
+            const cursorIdx = mutualIds.indexOf(options.cursor);
+            if (cursorIdx !== -1) {
+                startIndex = cursorIdx + 1;
+            }
+        }
+        const page = mutualIds.slice(startIndex, startIndex + limit);
+        const hasMore = startIndex + limit < mutualIds.length;
+        // Look up profiles for the page
+        const profiles = [];
+        for (const id of page) {
+            const record = await this.userProfilesCollection
+                .findOne({ _id: id })
+                .exec();
+            if (record) {
+                profiles.push(this.recordToProfile(record));
+            }
+        }
+        return {
+            items: profiles,
+            cursor: hasMore && page.length > 0 ? page[page.length - 1] : undefined,
+            hasMore,
+        };
+    }
+    /**
+     * Get the count of mutual connections between two users.
+     * Uses an in-memory cache with a 5-minute TTL for performance.
+     * @see Requirements: 28.1, 28.5
+     */
+    async getMutualConnectionCount(userId, otherUserId) {
+        const key = this.mutualCacheKey(userId, otherUserId);
+        const cached = this.mutualConnectionCache.get(key);
+        const now = Date.now();
+        if (cached &&
+            now - cached.timestamp < ConnectionService.MUTUAL_CACHE_TTL_MS) {
+            return cached.count;
+        }
+        // Cache miss – compute intersection count
+        const [userFollows, otherFollows] = await Promise.all([
+            this.getFollowedIds(userId),
+            this.getFollowedIds(otherUserId),
+        ]);
+        let count = 0;
+        for (const id of userFollows) {
+            if (otherFollows.has(id)) {
+                count++;
+            }
+        }
+        this.mutualConnectionCache.set(key, { count, timestamp: now });
+        return count;
+    }
+    // ═══════════════════════════════════════════════════════
+    // Block/Mute Inheritance for Lists (Requirements 32.1-32.5)
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Remove a blocked user from ALL lists owned by the blocker.
+     * Finds every list owned by ownerId, removes blockedUserId from each,
+     * and decrements member counts accordingly.
+     * @see Requirements: 32.1
+     */
+    async removeBlockedUserFromLists(ownerId, blockedUserId) {
+        // Get all lists owned by the blocker
+        const lists = await this.listsCollection
+            .find({ ownerId })
+            .exec();
+        for (const list of lists) {
+            // Try to remove the blocked user from this list's members
+            const result = await this.listMembersCollection
+                .deleteOne({
+                listId: list._id,
+                userId: blockedUserId,
+            })
+                .exec();
+            // Decrement member count if a record was actually removed
+            if (result.deletedCount > 0) {
+                const newCount = Math.max(0, list.memberCount - 1);
+                await this.listsCollection
+                    .updateOne({ _id: list._id }, {
+                    memberCount: newCount,
+                    updatedAt: new Date().toISOString(),
+                })
+                    .exec();
+            }
+        }
+    }
+    /**
+     * Check if a user is blocked by the list owner.
+     * Used to prevent blocked users from viewing or following lists.
+     * @see Requirements: 32.2, 32.3
+     */
+    async isBlockedFromList(userId, listOwnerId) {
+        const block = await this.blocksCollection
+            .findOne({
+            blockerId: listOwnerId,
+            blockedId: userId,
+        })
+            .exec();
+        return block !== null;
+    }
+    // ═══════════════════════════════════════════════════════
+    // List Following Operations
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Follow a public list. Verifies the list exists, is public,
+     * the user is not blocked, and is not already following.
+     * Increments the list's followerCount.
+     * @see Requirements: 33.1, 33.3
+     */
+    async followList(userId, listId) {
+        // Verify list exists
+        const list = await this.listsCollection
+            .findOne({ _id: listId })
+            .exec();
+        if (!list) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.ListNotFound, 'List not found');
+        }
+        // Only public lists can be followed
+        if (list.visibility !== brighthub_lib_1.ConnectionVisibility.Public) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.ListNotPublic, 'Only public lists can be followed');
+        }
+        // Check if user is blocked by the list owner
+        const isBlocked = await this.isBlockedFromList(userId, list.ownerId);
+        if (isBlocked) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.ListNotFound, 'List not found');
+        }
+        // Check if already following
+        const existing = await this.listFollowersCollection
+            .findOne({
+            listId,
+            userId,
+        })
+            .exec();
+        if (existing) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.AlreadyFollowingList, 'Already following this list');
+        }
+        // Create follower record
+        const now = new Date().toISOString();
+        await this.listFollowersCollection.create({
+            _id: (0, crypto_1.randomUUID)(),
+            listId,
+            userId,
+            followedAt: now,
+        });
+        // Increment followerCount
+        await this.listsCollection
+            .updateOne({ _id: listId }, {
+            followerCount: list.followerCount + 1,
+            updatedAt: now,
+        })
+            .exec();
+    }
+    /**
+     * Unfollow a list, removing the subscription and decrementing followerCount.
+     * @see Requirements: 33.5
+     */
+    async unfollowList(userId, listId) {
+        // Verify the follower record exists
+        const existing = await this.listFollowersCollection
+            .findOne({
+            listId,
+            userId,
+        })
+            .exec();
+        if (!existing) {
+            throw new brighthub_lib_1.ConnectionServiceError(brighthub_lib_1.ConnectionServiceErrorCode.NotFollowingList, 'Not following this list');
+        }
+        // Delete follower record
+        await this.listFollowersCollection
+            .deleteOne({ _id: existing._id })
+            .exec();
+        // Decrement followerCount
+        const list = await this.listsCollection
+            .findOne({ _id: listId })
+            .exec();
+        if (list) {
+            const newCount = Math.max(0, list.followerCount - 1);
+            await this.listsCollection
+                .updateOne({ _id: listId }, {
+                followerCount: newCount,
+                updatedAt: new Date().toISOString(),
+            })
+                .exec();
+        }
+    }
+    /**
+     * Get all followers of a list with pagination.
+     * @see Requirements: 33.6
+     */
+    async getListFollowers(listId, options) {
+        const limit = this.getLimit(options);
+        const queryLimit = limit + 1;
+        let query = this.listFollowersCollection.find({
+            listId,
+        });
+        if (query.sort) {
+            query = query.sort({ followedAt: -1 });
+        }
+        const allFollowers = await query.exec();
+        let filteredFollowers = allFollowers;
+        if (options?.cursor) {
+            filteredFollowers = allFollowers.filter((f) => f.followedAt < options.cursor);
+        }
+        const paginatedFollowers = filteredFollowers.slice(0, queryLimit);
+        const hasMore = paginatedFollowers.length > limit;
+        const resultFollowers = hasMore
+            ? paginatedFollowers.slice(0, limit)
+            : paginatedFollowers;
+        // Resolve user profiles
+        const items = [];
+        for (const record of resultFollowers) {
+            const profile = await this.userProfilesCollection
+                .findOne({ _id: record.userId })
+                .exec();
+            if (profile) {
+                items.push(this.recordToProfile(profile));
+            }
+        }
+        const lastFollower = resultFollowers[resultFollowers.length - 1];
+        return {
+            items,
+            cursor: hasMore && lastFollower ? lastFollower.followedAt : undefined,
+            hasMore,
+        };
+    }
+    /**
+     * Get all lists a user follows with pagination.
+     * @see Requirements: 33.6
+     */
+    async getFollowedLists(userId, options) {
+        const limit = this.getLimit(options);
+        const queryLimit = limit + 1;
+        let query = this.listFollowersCollection.find({
+            userId,
+        });
+        if (query.sort) {
+            query = query.sort({ followedAt: -1 });
+        }
+        const allFollowed = await query.exec();
+        let filteredFollowed = allFollowed;
+        if (options?.cursor) {
+            filteredFollowed = allFollowed.filter((f) => f.followedAt < options.cursor);
+        }
+        const paginatedFollowed = filteredFollowed.slice(0, queryLimit);
+        const hasMore = paginatedFollowed.length > limit;
+        const resultFollowed = hasMore
+            ? paginatedFollowed.slice(0, limit)
+            : paginatedFollowed;
+        // Resolve list details
+        const items = [];
+        for (const record of resultFollowed) {
+            const list = await this.listsCollection
+                .findOne({ _id: record.listId })
+                .exec();
+            if (list) {
+                items.push(this.recordToList(list));
+            }
+        }
+        const lastFollowed = resultFollowed[resultFollowed.length - 1];
+        return {
+            items,
+            cursor: hasMore && lastFollowed ? lastFollowed.followedAt : undefined,
+            hasMore,
+        };
+    }
+    /**
+     * Remove all non-owner followers when a list becomes private.
+     * Deletes all follower records and resets followerCount to 0.
+     * @see Requirements: 33.7
+     */
+    async removeNonOwnerFollowersOnPrivate(listId, ownerId) {
+        // Get all followers for this list
+        const followers = await this.listFollowersCollection
+            .find({ listId })
+            .exec();
+        // Delete all follower records (owner wouldn't normally follow their own list,
+        // but skip them just in case)
+        for (const follower of followers) {
+            if (follower.userId !== ownerId) {
+                await this.listFollowersCollection
+                    .deleteOne({ _id: follower._id })
+                    .exec();
+            }
+        }
+        // Reset followerCount to 0
+        await this.listsCollection
+            .updateOne({ _id: listId }, {
+            followerCount: 0,
+            updatedAt: new Date().toISOString(),
+        })
+            .exec();
+    }
+}
+exports.ConnectionService = ConnectionService;
+/**
+ * Factory function to create a ConnectionService instance
+ * @param application Application with database collection access
+ * @returns A new ConnectionService instance
+ */
+function createConnectionService(application) {
+    return new ConnectionService(application);
+}
+//# sourceMappingURL=connectionService.js.map