feat: Room List Bridge

.changeset/chatty-dingos-bathe.md

@@ -0,0 +1,7 @@
+---
+'@rocket.chat/apps-engine': minor
+'@rocket.chat/apps': minor
+'@rocket.chat/meteor': minor
+---
+
+Adds room listing to the Apps Engine bridge to let apps retrieve rooms by type and provide workspace-wide visibility.

apps/meteor/app/apps/server/bridges/rooms.ts

@@ -1,13 +1,13 @@
 import type { IAppServerOrchestrator } from '@rocket.chat/apps';
 import type { IMessage, IMessageRaw } from '@rocket.chat/apps-engine/definition/messages';
-import type { IRoom } from '@rocket.chat/apps-engine/definition/rooms';
+import type { IRoom, IRoomRaw } from '@rocket.chat/apps-engine/definition/rooms';
 import { RoomType } from '@rocket.chat/apps-engine/definition/rooms';
 import type { IUser } from '@rocket.chat/apps-engine/definition/users';
-import type { GetMessagesOptions } from '@rocket.chat/apps-engine/server/bridges/RoomBridge';
+import type { GetMessagesOptions, GetRoomsOptions } from '@rocket.chat/apps-engine/server/bridges/RoomBridge';
 import { RoomBridge } from '@rocket.chat/apps-engine/server/bridges/RoomBridge';
 import type { ISubscription, IUser as ICoreUser, IRoom as ICoreRoom, IMessage as ICoreMessage } from '@rocket.chat/core-typings';
 import { Subscriptions, Users, Rooms, Messages } from '@rocket.chat/models';
-import type { FindOptions, Sort } from 'mongodb';
+import type { FindOptions, Filter, Sort } from 'mongodb';
 
 import { createDirectMessage } from '../../../../server/methods/createDirectMessage';
 import { createDiscussion } from '../../../discussion/server/methods/createDiscussion';
@@ -151,6 +151,36 @@ export class AppRoomBridge extends RoomBridge {
 		return promises as Promise<IUser[]>;
 	}
 
+	protected async getAllRooms(options: GetRoomsOptions = {}, appId: string): Promise<Array<IRoomRaw>> {
+		this.orch.debugLog(`The App ${appId} is getting all rooms with options`, options);
+
+		const { types, limit = 100, skip = 0 } = options || {};
+
+		const { query } = this.buildRoomQuery(types);
+
+		const findOptions: FindOptions<ICoreRoom> = {
+			sort: { ts: -1 },
+			skip,
+			limit: Math.min(limit, 100),
+		};
+
+		const rooms: IRoomRaw[] = [];
+
+		const roomConverter = this.orch.getConverters()?.get('rooms');
+		if (!roomConverter) {
+			throw new Error('Room converter not found');
+		}
+
+		for await (const room of Rooms.find(query, findOptions)) {
+			const converted = await roomConverter.convertRoomRaw(room);
+			if (converted) {
+				rooms.push(converted);
+			}
+		}
+
+		return rooms;
+	}
+
 	protected async getDirectByUsernames(usernames: Array<string>, appId: string): Promise<IRoom | undefined> {
 		this.orch.debugLog(`The App ${appId} is getting direct room by usernames: "${usernames}"`);
 		const room = await Rooms.findDirectRoomContainingAllUsernames(usernames, {});
@@ -314,4 +344,79 @@ export class AppRoomBridge extends RoomBridge {
 		const members = await Users.findUsersByUsernames(usernames, { limit: 50 }).toArray();
 		await Promise.all(members.map((user) => removeUserFromRoom(roomId, user)));
 	}
+
+	private buildRoomQuery(types?: Array<RoomType>): { query: Filter<ICoreRoom> } {
+		if (!types || types.length === 0) {
+			return { query: {} };
+		}
+
+		const baseTypes = new Set<ICoreRoom['t']>();
+		let includeDiscussions = false;
+		let includeTeams = false;
+
+		for (const type of types) {
+			if (type === RoomType.DISCUSSION) {
+				includeDiscussions = true;
+				continue;
+			}
+
+			if (type === RoomType.TEAM) {
+				includeTeams = true;
+				continue;
+			}
+
+			if (type === RoomType.CHANNEL) {
+				baseTypes.add('c');
+				continue;
+			}
+
+			if (type === RoomType.PRIVATE_GROUP) {
+				baseTypes.add('p');
+				continue;
+			}
+
+			if (type === RoomType.DIRECT_MESSAGE) {
+				baseTypes.add('d');
+				continue;
+			}
+
+			if (type === RoomType.LIVE_CHAT) {
+				baseTypes.add('l');
+			}
+		}
+
+		const conditions: Array<Filter<ICoreRoom>> = [];
+
+		if (baseTypes.size) {
+			const baseCondition: Filter<ICoreRoom> = { t: { $in: Array.from(baseTypes) } };
+
+			if (!includeDiscussions) {
+				baseCondition.prid = { $exists: false };
+			}
+
+			if (!includeTeams) {
+				baseCondition.teamMain = { $ne: true };
+			}
+
+			conditions.push(baseCondition);
+		}
+
+		if (includeDiscussions) {
+			conditions.push({ prid: { $exists: true } });
+		}
+
+		if (includeTeams) {
+			conditions.push({ teamMain: true });
+		}
+
+		if (!conditions.length) {
+			return { query: {} };
+		}
+
+		if (conditions.length === 1) {
+			return { query: conditions[0] };
+		}
+
+		return { query: { $or: conditions } };
+	}
 }

apps/meteor/app/apps/server/converters/rooms.js

@@ -20,6 +20,44 @@ export class AppRoomsConverter {
 		return this.convertRoom(room);
 	}
 
+	async convertRoomRaw(room) {
+		if (!room) {
+			return undefined;
+		}
+
+		const creator = room.u
+			? {
+					_id: room.u._id,
+					username: room.u.username,
+					name: room.u.name,
+				}
+			: undefined;
+
+		const type = this._resolveRoomType(room);
+
+		return {
+			id: room._id,
+			slugifiedName: room.name || room.fname || room._id,
+			displayName: room.fname,
+			type,
+			creator,
+			userIds: room.uids,
+			isDefault: !!room.default,
+			isReadOnly: !!room.ro,
+			displaySystemMessages: typeof room.sysMes === 'undefined' ? true : room.sysMes,
+			messageCount: room.msgs,
+			createdAt: room.ts,
+			updatedAt: room._updatedAt,
+			lastModifiedAt: room.lm,
+			description: room.description,
+			customFields: room.customFields,
+			parentRoomId: room.prid,
+			teamId: room.teamId,
+			isTeamMain: !!room.teamMain,
+			livechatData: room.livechatData,
+		};
+	}
+
 	async __getCreator(user) {
 		if (!user) {
 			return;
@@ -176,11 +214,15 @@ export class AppRoomsConverter {
 		return newRoom;
 	}
 
-	async convertRoom(originalRoom) {
+	async convertRoom(originalRoom, { lightweight = false } = {}) {
 		if (!originalRoom) {
 			return undefined;
 		}
 
+		if (lightweight) {
+			return this.convertRoomWithoutLookups(originalRoom);
+		}
+
 		const map = {
 			id: '_id',
 			displayName: 'fname',
@@ -221,9 +263,9 @@ export class AppRoomsConverter {
 				return sysMes;
 			},
 			type: (room) => {
-				const result = this._convertTypeToApp(room.t);
+				const derivedType = this._resolveRoomType(room);
 				delete room.t;
-				return result;
+				return derivedType;
 			},
 			creator: async (room) => {
 				const { u } = room;
@@ -337,6 +379,54 @@ export class AppRoomsConverter {
 		return transformMappedData(originalRoom, map);
 	}
 
+	convertRoomWithoutLookups(room) {
+		const creatorFromRoom = room.u
+			? {
+					_id: room.u._id,
+					username: room.u.username,
+					name: room.u.name || room.u.username || 'Unknown',
+				}
+			: undefined;
+
+		const fallbackUser = {
+			_id: 'unknown',
+			username: 'unknown',
+			name: 'Unknown',
+		};
+
+		return {
+			id: room._id,
+			displayName: room.fname,
+			slugifiedName: room.name || room.fname || room._id,
+			type: this._resolveRoomType(room),
+			creator: creatorFromRoom || fallbackUser,
+			usernames: room.usernames || [],
+			userIds: room.uids || [],
+			isDefault: !!room.default,
+			isReadOnly: !!room.ro,
+			displaySystemMessages: typeof room.sysMes === 'undefined' ? true : room.sysMes,
+			messageCount: room.msgs,
+			createdAt: room.ts,
+			updatedAt: room._updatedAt,
+			lastModifiedAt: room.lm,
+			description: room.description,
+			customFields: room.customFields,
+			livechatData: room.livechatData,
+		};
+	}
+
+	_resolveRoomType(room) {
+		if (room.teamMain) {
+			return RoomType.TEAM;
+		}
+
+		if (room.prid) {
+			return RoomType.DISCUSSION;
+		}
+
+		return this._convertTypeToApp(room.t);
+	}
+
 	_convertTypeToApp(typeChar) {
 		switch (typeChar) {
 			case 'c':

packages/apps-engine/src/definition/accessors/IRoomRead.ts

@@ -1,6 +1,6 @@
-import type { GetMessagesOptions } from '../../server/bridges/RoomBridge';
+import type { GetMessagesOptions, GetRoomsOptions } from '../../server/bridges/RoomBridge';
 import type { IMessageRaw } from '../messages/index';
-import type { IRoom } from '../rooms/index';
+import type { IRoom, IRoomRaw } from '../rooms/index';
 import type { IUser } from '../users/index';
 
 /**
@@ -61,6 +61,14 @@ export interface IRoomRead {
 	 */
 	getMembers(roomId: string): Promise<Array<IUser>>;
 
+	/**
+	 * Retrieves all rooms in the workspace, optionally filtered by type or other flags.
+	 *
+	 * @param options Optional filters such as types and pagination
+	 * @returns a list of lightweight rooms
+	 */
+	getAllRooms(options?: Partial<GetRoomsOptions>): Promise<Array<IRoomRaw>>;
+
 	/**
 	 * Gets a direct room with all usernames
 	 * @param usernames all usernames belonging to the direct room

packages/apps-engine/src/definition/rooms/IRoomRaw.ts

@@ -0,0 +1,28 @@
+import type { IUserLookup } from '../users';
+import type { RoomType } from './RoomType';
+
+/**
+ * A lightweight representation of a room without resolving relational data.
+ * This is intended for listing operations to avoid additional database lookups.
+ */
+export interface IRoomRaw {
+	id: string;
+	slugifiedName: string;
+	displayName?: string;
+	type: RoomType;
+	creator?: IUserLookup;
+	userIds?: Array<string>;
+	isDefault?: boolean;
+	isReadOnly?: boolean;
+	displaySystemMessages?: boolean;
+	messageCount?: number;
+	createdAt?: Date;
+	updatedAt?: Date;
+	lastModifiedAt?: Date;
+	description?: string;
+	customFields?: { [key: string]: any };
+	parentRoomId?: string;
+	teamId?: string;
+	isTeamMain?: boolean;
+	livechatData?: { [key: string]: any };
+}

packages/apps-engine/src/definition/rooms/RoomType.ts

@@ -3,4 +3,6 @@ export enum RoomType {
 	PRIVATE_GROUP = 'p',
 	DIRECT_MESSAGE = 'd',
 	LIVE_CHAT = 'l',
+	DISCUSSION = 'discussion',
+	TEAM = 'team',
 }

packages/apps-engine/src/definition/rooms/index.ts

@@ -5,10 +5,12 @@ import { IPreRoomCreateModify } from './IPreRoomCreateModify';
 import { IPreRoomCreatePrevent } from './IPreRoomCreatePrevent';
 import { IPreRoomDeletePrevent } from './IPreRoomDeletePrevent';
 import { IRoom } from './IRoom';
+import { IRoomRaw } from './IRoomRaw';
 import { RoomType } from './RoomType';
 
 export {
 	IRoom,
+	IRoomRaw,
 	RoomType,
 	IPostRoomCreate,
 	IPostRoomDeleted,

packages/apps-engine/src/server/accessors/RoomRead.ts

@@ -1,9 +1,9 @@
 import type { IRoomRead } from '../../definition/accessors';
 import type { IMessageRaw } from '../../definition/messages';
-import type { IRoom } from '../../definition/rooms';
+import type { IRoom, IRoomRaw } from '../../definition/rooms';
 import type { IUser } from '../../definition/users';
 import type { RoomBridge } from '../bridges';
-import { type GetMessagesOptions, GetMessagesSortableFields } from '../bridges/RoomBridge';
+import { type GetMessagesOptions, type GetRoomsOptions, GetMessagesSortableFields } from '../bridges/RoomBridge';
 
 export class RoomRead implements IRoomRead {
 	constructor(
@@ -46,6 +46,27 @@ export class RoomRead implements IRoomRead {
 		return this.roomBridge.doGetMembers(roomId, this.appId);
 	}
 
+	public getAllRooms(options: Partial<GetRoomsOptions> = {}): Promise<Array<IRoomRaw>> {
+		const limit = options.limit ?? 100;
+
+		if (!Number.isFinite(limit) || limit <= 0 || limit > 100) {
+			throw new Error(`Invalid limit provided. Expected number between 1 and 100, got ${limit}`);
+		}
+
+		if (typeof options.skip !== 'undefined' && (!Number.isFinite(options.skip) || options.skip < 0)) {
+			throw new Error(`Invalid skip provided. Expected number >= 0, got ${options.skip}`);
+		}
+
+		return this.roomBridge.doGetAllRooms(
+			{
+				...options,
+				limit,
+				skip: options.skip ?? 0,
+			},
+			this.appId,
+		);
+	}
+
 	public getDirectByUsernames(usernames: Array<string>): Promise<IRoom> {
 		return this.roomBridge.doGetDirectByUsernames(usernames, this.appId);
 	}