Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
5.0 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

import type {GuildID, MessageID, UserID} from '@app/api/BrandedTypes';
import {dispatchChannelEvent} from '@app/api/channel/services/ChannelGatewayDispatch';
import {createMessageResponseDataService} from '@app/api/channel/services/message/MessageResponseDataService';
import type {IGatewayService} from '@app/api/infrastructure/IGatewayService';
import {getUserRepository} from '@app/api/middleware/ServiceSingletons';
import type {Channel} from '@app/api/models/Channel';
import type {Message} from '@app/api/models/Message';
import {isContentHidden} from '@app/api/user/UserHelpers';
import {ChannelTypes, MessageTypes} from '@fluxer/constants/src/ChannelConstants';
import type {MessageResponse} from '@fluxer/schema/src/domains/message/MessageResponseSchemas';

interface BuildBroadcastMessageDataParams {
	channel: Channel;
	message: Message;
	currentUserId?: UserID;
	nonce?: string;
	tts?: boolean;
	sourceGuildId?: GuildID | null;
}

interface BuildBroadcastMessageCreateDataParams extends BuildBroadcastMessageDataParams {
	mentionHere?: boolean;
}

type MessageCreateBroadcastData = MessageResponse & {
	channel_type: Channel['type'];
	nicks?: Record<string, string>;
	mention_here?: true;
	channel_nsfw?: true;
};

export async function buildBroadcastMessageData({
	channel,
	message,
	currentUserId,
	nonce,
	tts,
	sourceGuildId,
}: BuildBroadcastMessageDataParams): Promise<MessageResponse> {
	return createMessageResponseDataService().buildBroadcastMessage({
		channel,
		message,
		userId: currentUserId,
		nonce,
		tts,
		sourceGuildId,
	});
}

async function buildBroadcastMessageCreateData(
	params: BuildBroadcastMessageCreateDataParams,
): Promise<MessageCreateBroadcastData> {
	const messageResponse = await buildBroadcastMessageData(params);
	if (params.message.type === MessageTypes.CHANNEL_PINNED_MESSAGE) {
		delete messageResponse.referenced_message;
	}
	const groupDmNicks = serializeGroupDmNicks(params.channel);
	return {
		...messageResponse,
		channel_type: params.channel.type,
		...(groupDmNicks ? {nicks: groupDmNicks} : {}),
		...(params.mentionHere ? {mention_here: true} : {}),
		...(params.channel.type === ChannelTypes.GROUP_DM && params.channel.isNsfw ? {channel_nsfw: true} : {}),
	};
}

function serializeGroupDmNicks(channel: Channel): Record<string, string> | undefined {
	if (channel.type !== ChannelTypes.GROUP_DM || !channel.nicknames || channel.nicknames.size === 0) {
		return undefined;
	}
	const nicks: Record<string, string> = {};
	for (const [userId, nickname] of channel.nicknames) {
		nicks[String(userId)] = nickname;
	}
	return Object.keys(nicks).length > 0 ? nicks : undefined;
}

export async function dispatchMessageCreateBroadcast({
	gatewayService,
	...params
}: BuildBroadcastMessageCreateDataParams & {
	gatewayService: IGatewayService;
}): Promise<void> {
	await dispatchChannelEvent({
		gatewayService,
		channel: params.channel,
		event: 'MESSAGE_CREATE',
		data: await buildBroadcastMessageCreateData(params),
	});
}

export async function dispatchMessageCreateToUser({
	gatewayService,
	userId,
	...params
}: BuildBroadcastMessageCreateDataParams & {
	gatewayService: IGatewayService;
	userId: UserID;
}): Promise<void> {
	await gatewayService.dispatchPresence({
		userId,
		event: 'MESSAGE_CREATE',
		data: await buildBroadcastMessageCreateData(params),
	});
}

export async function findContentHiddenAuthorId(message: Message): Promise<UserID | null> {
	if (!message.authorId) return null;
	const author = await getUserRepository().findUnique(message.authorId);
	return author && isContentHidden(author, message.id) ? author.id : null;
}

export async function dispatchMessageUpdateBroadcast({
	gatewayService,
	...params
}: BuildBroadcastMessageDataParams & {
	gatewayService: IGatewayService;
}): Promise<void> {
	const data = await buildBroadcastMessageData(params);
	const hiddenAuthorId = await findContentHiddenAuthorId(params.message);
	if (hiddenAuthorId) {
		await gatewayService.dispatchPresence({userId: hiddenAuthorId, event: 'MESSAGE_UPDATE', data});
		return;
	}
	await dispatchChannelEvent({
		gatewayService,
		channel: params.channel,
		event: 'MESSAGE_UPDATE',
		data,
	});
}

export async function dispatchMessageDelete({
	gatewayService,
	channel,
	messageId,
	message,
}: {
	gatewayService: IGatewayService;
	channel: Channel;
	messageId: MessageID;
	message: Message;
}): Promise<void> {
	await dispatchChannelEvent({
		gatewayService,
		channel,
		event: 'MESSAGE_DELETE',
		data: {
			channel_id: channel.id.toString(),
			id: messageId.toString(),
			content: message.content,
			author_id: message.authorId?.toString(),
		},
	});
}

export async function dispatchMessageDeleteBulk({
	gatewayService,
	channel,
	messageIds,
}: {
	gatewayService: IGatewayService;
	channel: Channel;
	messageIds: Array<MessageID>;
}): Promise<void> {
	await dispatchChannelEvent({
		gatewayService,
		channel,
		event: 'MESSAGE_DELETE_BULK',
		data: {
			channel_id: channel.id.toString(),
			ids: messageIds.map((id) => id.toString()),
		},
	});
}