upstream-rocketchat/apps/meteor/client/lib/chats/data.ts

import { isEncryptedMessageContent, type IEditedMessage, type IMessage, type IRoom, type ISubscription } from '@rocket.chat/core-typings';
import { MessageTypes } from '@rocket.chat/message-types';
import { Random } from '@rocket.chat/random';
import { differenceInMinutes } from 'date-fns';

import type { DataAPI } from './ChatAPI';
import { Messages, Rooms, Subscriptions } from '../../stores';
import { sdk } from '../SDKClient';
import { hasAtLeastOnePermission, hasPermission } from '../authorization';
import { settings } from '../settings';
import { getUserId } from '../user';
import { mapMessageFromApi } from '../utils/mapMessageFromApi';
import { prependReplies } from '../utils/prependReplies';
import { upsertThreadMessageInCache } from '../utils/threadMessageUtils';

export const createDataAPI = ({ rid, tmid }: { rid: IRoom['_id']; tmid: IMessage['_id'] | undefined }): DataAPI => {
	const composeMessage = async (
		text: string,
		{ sendToChannel, quotedMessages, originalMessage }: { sendToChannel?: boolean; quotedMessages: IMessage[]; originalMessage?: IMessage },
	): Promise<IMessage> => {
		const msg = await prependReplies(text, quotedMessages);

		const effectiveRID = originalMessage?.rid ?? rid;
		const effectiveTMID = originalMessage ? originalMessage.tmid : tmid;

		return {
			_id: originalMessage?._id ?? Random.id(),
			rid: effectiveRID,
			...(effectiveTMID && {
				tmid: effectiveTMID,
				...(sendToChannel && { tshow: sendToChannel }),
			}),
			msg,
		} as IMessage;
	};

	const findMessageByID = async (mid: IMessage['_id']): Promise<IMessage | null> =>
		Messages.state.find((record) => record._id === mid && record._hidden !== true) ??
		sdk.rest.get('/v1/chat.getMessage', { msgId: mid }).then((response) => mapMessageFromApi(response.message));

	const getMessageByID = async (mid: IMessage['_id']): Promise<IMessage> => {
		const message = await findMessageByID(mid);

		if (!message) {
			throw new Error('Message not found');
		}

		return message;
	};

	const findLastMessage = async (): Promise<IMessage | undefined> =>
		Messages.state.findFirst(
			(record) => record.rid === rid && (tmid ? record.tmid === tmid : !record.tmid) && record._hidden !== true,
			(a, b) => b.ts.getTime() - a.ts.getTime(),
		);

	const getLastMessage = async (): Promise<IMessage> => {
		const message = await findLastMessage();

		if (!message) {
			throw new Error('Message not found');
		}

		return message;
	};

	const canUpdateMessage = async (message: IMessage): Promise<boolean> => {
		if (MessageTypes.isSystemMessage(message)) {
			return false;
		}

		const canEditMessage = hasAtLeastOnePermission('edit-message', message.rid);
		const editAllowed = settings.peek('Message_AllowEditing') ?? false;
		const editOwn = message?.u && message.u._id === getUserId();

		if (!canEditMessage && (!editAllowed || !editOwn)) {
			return false;
		}

		const blockEditInMinutes = settings.peek('Message_AllowEditing_BlockEditInMinutes');
		const bypassBlockTimeLimit = hasPermission('bypass-time-limit-edit-and-delete', message.rid);

		const elapsedMinutes = differenceInMinutes(new Date(), message.ts);
		if (!bypassBlockTimeLimit && elapsedMinutes && blockEditInMinutes && elapsedMinutes > blockEditInMinutes) {
			return false;
		}

		return true;
	};

	const findPreviousOwnMessage = async (message?: IMessage): Promise<IMessage | undefined> => {
		const uid = getUserId();

		if (!uid) {
			return undefined;
		}

		const msg = Messages.state.findFirst(
			(record) =>
				record.rid === rid &&
				(tmid ? record.tmid === tmid : !record.tmid) &&
				record.u._id === uid &&
				record._hidden !== true &&
				record.ts.getTime() < (message?.ts.getTime() ?? Date.now()),
			(a, b) => b.ts.getTime() - a.ts.getTime(),
		);

		if (!msg) {
			return undefined;
		}

		if (await canUpdateMessage(msg)) {
			return msg;
		}

		return findPreviousOwnMessage(msg);
	};

	const getPreviousOwnMessage = async (message: IMessage): Promise<IMessage> => {
		const previousMessage = await findPreviousOwnMessage(message);

		if (!previousMessage) {
			throw new Error('Message not found');
		}

		return previousMessage;
	};

	const findNextOwnMessage = async (message: IMessage): Promise<IMessage | undefined> => {
		const uid = getUserId();

		if (!uid) {
			return undefined;
		}

		const msg = Messages.state.findFirst(
			(record) =>
				record.rid === rid &&
				(tmid ? record.tmid === tmid : !record.tmid) &&
				record.u._id === uid &&
				record._hidden !== true &&
				record.ts.getTime() > message.ts.getTime(),
			(a, b) => a.ts.getTime() - b.ts.getTime(),
		);

		if (!msg) {
			return undefined;
		}

		if (await canUpdateMessage(msg)) {
			return msg;
		}

		return findNextOwnMessage(msg);
	};

	const getNextOwnMessage = async (message: IMessage): Promise<IMessage> => {
		const nextMessage = await findNextOwnMessage(message);

		if (!nextMessage) {
			throw new Error('Message not found');
		}

		return nextMessage;
	};

	const pushEphemeralMessage = async (message: Omit<IMessage, 'rid' | 'tmid'>): Promise<void> => {
		const fullMessage = { ...message, rid, ...(tmid && { tmid }) };
		Messages.state.store(fullMessage);

		if (tmid) {
			upsertThreadMessageInCache(fullMessage, rid, tmid);
		}
	};

	const updateMessage = async (message: IEditedMessage, previewUrls?: string[]): Promise<void> => {
		const params = isEncryptedMessageContent(message)
			? {
					msgId: message._id,
					roomId: message.rid,
					content: message.content,
					e2eMentions: message.e2eMentions,
				}
			: {
					previewUrls,
					msgId: message._id,
					roomId: message.rid,
					customFields: message.customFields,
					text: message.msg,
				};

		await sdk.rest.post('/v1/chat.update', params);
	};

	const canDeleteMessage = async (message: IMessage): Promise<boolean> => {
		const uid = getUserId();

		if (!uid) {
			return false;
		}

		if (MessageTypes.isSystemMessage(message)) {
			return false;
		}

		const forceDeleteAllowed = hasPermission('force-delete-message', message.rid);
		if (forceDeleteAllowed) {
			return true;
		}

		const deletionEnabled = settings.peek('Message_AllowDeleting');
		if (!deletionEnabled) {
			return false;
		}

		const deleteAnyAllowed = hasPermission('delete-message', rid);
		const deleteOwnAllowed = hasPermission('delete-own-message');
		const deleteAllowed = deleteAnyAllowed || (deleteOwnAllowed && message?.u && message.u._id === getUserId());

		if (!deleteAllowed) {
			return false;
		}

		const blockDeleteInMinutes = settings.peek('Message_AllowDeleting_BlockDeleteInMinutes');
		const bypassBlockTimeLimit = hasPermission('bypass-time-limit-edit-and-delete', message.rid);
		const elapsedMinutes = differenceInMinutes(new Date(), message.ts);
		const onTimeForDelete = bypassBlockTimeLimit || !blockDeleteInMinutes || !elapsedMinutes || elapsedMinutes <= blockDeleteInMinutes;

		return deleteAllowed && onTimeForDelete;
	};

	const deleteMessage = async (msgIdOrMsg: IMessage | IMessage['_id']): Promise<void> => {
		let msgId: string;
		let roomId: string;
		if (typeof msgIdOrMsg === 'string') {
			msgId = msgIdOrMsg;
			const msg = await findMessageByID(msgId);
			if (!msg) {
				throw new Error('Message not found');
			}
			roomId = msg.rid;
		} else {
			msgId = msgIdOrMsg._id;
			roomId = msgIdOrMsg.rid;
		}

		await sdk.rest.post('/v1/chat.delete', { msgId, roomId });
	};

	const drafts = new Map<IMessage['_id'] | undefined, string>();

	const getDraft = async (mid: IMessage['_id'] | undefined): Promise<string | undefined> => drafts.get(mid);

	const discardDraft = async (mid: IMessage['_id'] | undefined): Promise<void> => {
		drafts.delete(mid);
	};

	const saveDraft = async (mid: IMessage['_id'] | undefined, draft: string): Promise<void> => {
		drafts.set(mid, draft);
	};

	const findRoom = async (): Promise<IRoom | undefined> => Rooms.state.get(rid);

	const getRoom = async (): Promise<IRoom> => {
		const room = await findRoom();

		if (!room) {
			throw new Error('Room not found');
		}

		return room;
	};

	const isSubscribedToRoom = async (): Promise<boolean> => !!Subscriptions.state.find((record) => record.rid === rid);

	const joinRoom = async (): Promise<void> => {
		await sdk.rest.post('/v1/rooms.join', { roomId: rid });
	};

	const findDiscussionByID = async (drid: IRoom['_id']): Promise<IRoom | undefined> =>
		Rooms.state.find((record) => Boolean(record._id === drid && record.prid));

	const getDiscussionByID = async (drid: IRoom['_id']): Promise<IRoom> => {
		const discussion = await findDiscussionByID(drid);

		if (!discussion) {
			throw new Error('Discussion not found');
		}

		return discussion;
	};

	const createStrictGetter = <TFind extends (...args: any[]) => Promise<any>>(
		find: TFind,
		errorMessage: string,
	): ((...args: Parameters<TFind>) => Promise<Exclude<Awaited<ReturnType<TFind>>, undefined>>) => {
		return async (...args) => {
			const result = await find(...args);

			if (!result) {
				throw new Error(errorMessage);
			}

			return result;
		};
	};

	const findSubscription = async (): Promise<ISubscription | undefined> => {
		return Subscriptions.state.find((record) => record.rid === rid);
	};

	const getSubscription = createStrictGetter(findSubscription, 'Subscription not found');

	const findSubscriptionFromMessage = async (message: IMessage): Promise<ISubscription | undefined> => {
		return Subscriptions.state.find((record) => record.rid === message.rid);
	};

	const getSubscriptionFromMessage = createStrictGetter(findSubscriptionFromMessage, 'Subscription not found');

	return {
		composeMessage,
		findMessageByID,
		getMessageByID,
		findLastMessage,
		getLastMessage,
		findPreviousOwnMessage,
		getPreviousOwnMessage,
		findNextOwnMessage,
		getNextOwnMessage,
		pushEphemeralMessage,
		canUpdateMessage,
		updateMessage,
		canDeleteMessage,
		deleteMessage,
		getDraft,
		saveDraft,
		discardDraft,
		findRoom,
		getRoom,
		isSubscribedToRoom,
		joinRoom,
		findDiscussionByID,
		getDiscussionByID,
		findSubscription,
		getSubscription,
		findSubscriptionFromMessage,
		getSubscriptionFromMessage,
	};
};