nodebb-plugin-admin-chats 3.6.1 → 3.7.0

package/lib/activity.js

@@ -0,0 +1,88 @@
+'use strict';
+
+// Last-activity ordering for the admin chat list. Core only keeps such
+// ordering per user (`uid:<uid>:chat:rooms`, bumped on every message) — the
+// global `chat:rooms` set is scored once at room creation and never again,
+// so listing from it sorts by creation date and buries active rooms. This
+// module maintains a plugin-owned set scored like the per-user one.
+
+const Messaging = nodebb.require('./src/messaging');
+const db = nodebb.require('./src/database');
+
+const ACTIVITY_SET = 'admin-chats:rooms:lastpost';
+const BACKFILL_BATCH_SIZE = 100;
+
+function overrideForActivityTracking() {
+    if (typeof Messaging.addRoomToUsers === 'function' && !Messaging.addRoomToUsers._adminChatsActivityWrapped) {
+        const originalAddRoomToUsers = Messaging.addRoomToUsers;
+
+        // addRoomToUsers is core's own "bump this private room" signal — it runs
+        // on private room creation (src/messaging/rooms.js) and on every message
+        // (src/messaging/create.js), always with the activity timestamp.
+        const wrappedAddRoomToUsers = async function (roomId, uids, timestamp) {
+            await db.sortedSetAdd(ACTIVITY_SET, timestamp, roomId);
+            return await originalAddRoomToUsers.call(this, roomId, uids, timestamp);
+        };
+
+        wrappedAddRoomToUsers._adminChatsActivityWrapped = true;
+        Messaging.addRoomToUsers = wrappedAddRoomToUsers;
+    }
+
+    if (typeof Messaging.deleteRooms === 'function' && !Messaging.deleteRooms._adminChatsActivityWrapped) {
+        const originalDeleteRooms = Messaging.deleteRooms;
+
+        const wrappedDeleteRooms = async function (roomIds) {
+            const result = await originalDeleteRooms.call(this, roomIds);
+            await db.sortedSetRemove(ACTIVITY_SET, Array.isArray(roomIds) ? roomIds : [roomIds]);
+            return result;
+        };
+
+        wrappedDeleteRooms._adminChatsActivityWrapped = true;
+        Messaging.deleteRooms = wrappedDeleteRooms;
+    }
+}
+
+// Reconcile on startup: private rooms not yet in the activity set (created
+// before this feature existed, or while the plugin was disabled) get scored
+// by their last message's timestamp, falling back to room creation time.
+async function backfillActivitySet() {
+    const allRooms = await db.getSortedSetRangeWithScores('chat:rooms', 0, -1);
+    if (!allRooms.length) {
+        return;
+    }
+
+    const roomIds = allRooms.map(item => item.value);
+    const [inActivitySet, isPublic] = await Promise.all([
+        db.isSortedSetMembers(ACTIVITY_SET, roomIds),
+        db.isSortedSetMembers('chat:rooms:public', roomIds),
+    ]);
+
+    const missing = allRooms.filter((item, index) => !inActivitySet[index] && !isPublic[index]);
+
+    for (let offset = 0; offset < missing.length; offset += BACKFILL_BATCH_SIZE) {
+        const batch = missing.slice(offset, offset + BACKFILL_BATCH_SIZE);
+        const lastMessages = await Promise.all(
+            batch.map(item => db.getSortedSetRevRangeWithScores(`chat:room:${item.value}:mids`, 0, 0))
+        );
+        await db.sortedSetAddBulk(batch.map((item, index) => [
+            ACTIVITY_SET,
+            (lastMessages[index][0] && lastMessages[index][0].score) || item.score,
+            item.value,
+        ]));
+    }
+}
+
+// Entries whose room no longer resolves (deleted outside deleteRooms, or
+// before this module wrapped it) are pruned lazily by the room list.
+async function pruneActivityEntries(roomIds) {
+    if (roomIds.length) {
+        await db.sortedSetRemove(ACTIVITY_SET, roomIds);
+    }
+}
+
+module.exports = {
+    ACTIVITY_SET,
+    overrideForActivityTracking,
+    backfillActivitySet,
+    pruneActivityEntries,
+};

package/lib/routes.js

@@ -11,9 +11,9 @@ const sockets = nodebb.require('./src/socket.io');
 const { canAccessAdminChats, canManageAdminChats } = require('./access');
 const { getMessageEditHistory, deleteRevision } = require('./history');
 const { roomExists, lockRoom, unlockRoom, getRoomLockData } = require('./lock');
+const { ACTIVITY_SET, pruneActivityEntries } = require('./activity');
 
 const ADMIN_CHAT_PAGE_SIZE = 30;
-const ADMIN_CHAT_SCAN_SIZE = 100;
 
 async function assertAdminChatsAccess(req, res) {
     if (!req.uid || !await canAccessAdminChats(req.uid)) {
@@ -132,34 +132,32 @@ async function getPrivateRoomCount() {
 }
 
 async function getAdminRecentChats(uid, start, limit) {
-    let cursor = Math.max(0, parseInt(start, 10) || 0);
-    const roomPairs = [];
-
-    while (roomPairs.length < limit) {
-        const roomIds = await db.getSortedSetRevRange('chat:rooms', cursor, cursor + ADMIN_CHAT_SCAN_SIZE - 1);
-        if (!roomIds.length) {
-            break;
-        }
+    const cursor = Math.max(0, parseInt(start, 10) || 0);
 
-        const rooms = await Messaging.getRoomsData(roomIds);
-        rooms.forEach((room, index) => {
-            if (room && !room.public && roomPairs.length < limit) {
-                roomPairs.push({ roomId: roomIds[index], room });
-            }
-        });
+    // The activity set is scored by each room's last message (see lib/activity.js),
+    // so a plain reverse range yields the same most-recent-first ordering the
+    // user's own chats page gets from `uid:<uid>:chat:rooms`.
+    const allRoomIds = await db.getSortedSetRevRange(ACTIVITY_SET, cursor, cursor + limit - 1);
+    const allRooms = await Messaging.getRoomsData(allRoomIds);
 
-        cursor += roomIds.length;
-        if (roomIds.length < ADMIN_CHAT_SCAN_SIZE) {
-            break;
+    const roomPairs = [];
+    const staleRoomIds = [];
+    allRooms.forEach((room, index) => {
+        if (room && !room.public) {
+            roomPairs.push({ roomId: allRoomIds[index], room });
+        } else if (!room) {
+            staleRoomIds.push(allRoomIds[index]);
         }
-    }
+    });
+
+    await pruneActivityEntries(staleRoomIds);
 
     const rooms = roomPairs.map(item => item.room);
     const roomIds = roomPairs.map(item => item.roomId);
 
     await enrichAdminRecentRooms(uid, roomIds, rooms);
 
-    return { rooms, nextStart: cursor };
+    return { rooms, nextStart: cursor + allRoomIds.length };
 }
 
 async function enrichAdminRecentRooms(uid, roomIds, rooms) {

package/library.js

@@ -3,6 +3,7 @@
 const hooks = require('./lib/hooks');
 const { registerRoutes, renderAdminChatsPage } = require('./lib/routes');
 const { overrideMessagingFunctions, overrideChatsApi, overrideCoreChatRedirect } = require('./lib/overrides');
+const { overrideForActivityTracking, backfillActivitySet } = require('./lib/activity');
 
 const plugin = Object.assign({}, hooks);
 
@@ -11,6 +12,8 @@ plugin.init = async function (params) {
     overrideMessagingFunctions();
     overrideChatsApi();
     overrideCoreChatRedirect(params.controllers, renderAdminChatsPage);
+    overrideForActivityTracking();
+    await backfillActivitySet();
 };
 
 module.exports = plugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodebb-plugin-admin-chats",
-  "version": "3.6.1",
+  "version": "3.7.0",
   "description": "A plugin that allows the administrator to view and manage user chats.",
   "main": "library.js",
   "nbbpm": {