Skip to content

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

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

import {createGuildID, type UserID} from '@app/api/BrandedTypes';
import {Config} from '@app/api/Config';
import {stripAvatarForUser, stripBannerForUser} from '@app/api/infrastructure/AssetEntitlementUtils';
import type {IGatewayService} from '@app/api/infrastructure/IGatewayService';
import {resolveEffectiveUserTraits} from '@app/api/limits/EffectiveUserTraits';
import type {GuildChannelOverride} from '@app/api/models/GuildChannelOverride';
import type {GuildMember} from '@app/api/models/GuildMember';
import type {MuteConfiguration} from '@app/api/models/MuteConfiguration';
import type {Relationship} from '@app/api/models/Relationship';
import type {User} from '@app/api/models/User';
import type {UserGuildSettings} from '@app/api/models/UserGuildSettings';
import type {UserSettings} from '@app/api/models/UserSettings';
import type {WebAuthnCredential} from '@app/api/models/WebAuthnCredential';
import {isAccountLimited} from '@app/api/user/AccountLimit';
import {
	canReachOthers,
	getAccountTier,
	getVerificationNeed,
	isInteractionTierEnforced,
} from '@app/api/user/AccountTier';
import {isDateOfBirthMissing} from '@app/api/user/DateOfBirth';
import {hiddenUserPartial, isProfileHidden} from '@app/api/user/ProfileVisibility';
import {deprecatedBadgeHideFields} from '@app/api/user/profile_badges/HiddenProfileBadges';
import {canUserAccessNsfwContent} from '@app/api/utils/AgeUtils';
import {AccountTiers} from '@fluxer/constants/src/AccountTierConstants';
import type {ChannelMessageNotifications} from '@fluxer/constants/src/NotificationConstants';
import {
	DEFAULT_GUILD_FOLDER_ICON,
	DELETED_USER_DISCRIMINATOR,
	DELETED_USER_GLOBAL_NAME,
	DELETED_USER_USERNAME,
	type GuildFolderIcon,
	PremiumFlags,
	PUBLIC_USER_FLAGS,
	stripHiddenProfileBadgeFlags,
	UNCATEGORIZED_FOLDER_ID,
	type UserAuthenticatorType,
	UserAuthenticatorTypes,
	UserFlags,
	UserPremiumTypes,
} from '@fluxer/constants/src/UserConstants';
import type {WebAuthnCredentialResponse} from '@fluxer/schema/src/domains/auth/AuthSchemas';
import type {
	RelationshipResponse,
	UserGuildSettingsResponse,
	UserPartialResponse,
	UserPrivateResponse,
	UserProfileResponse,
	UserSettingsResponse,
} from '@fluxer/schema/src/domains/user/UserResponseSchemas';

function mapUserFlagsToPublicBitfield(user: User): number {
	return Number(stripHiddenProfileBadgeFlags(user.flags ?? 0n, user.hiddenProfileBadges) & PUBLIC_USER_FLAGS);
}

export function getActiveAuthenticatorTypes(user: User): Array<UserAuthenticatorType> {
	return Array.from(user.authenticatorTypes ?? []).filter(
		(type): type is UserAuthenticatorType =>
			type === UserAuthenticatorTypes.TOTP || type === UserAuthenticatorTypes.WEBAUTHN,
	);
}

function sortUserIds(userIds: Iterable<UserID>): Array<string> {
	return Array.from(userIds)
		.sort((left, right) => {
			if (left < right) {
				return -1;
			}
			if (left > right) {
				return 1;
			}
			return 0;
		})
		.map((userId) => userId.toString());
}

export function mapUserToPartialResponse(user: User): UserPartialResponse {
	const partial = mapUserToOwnPartialResponse(user);
	if (isProfileHidden(user) && !isDeletedForDisplay(user)) return hiddenUserPartial(partial);
	return isProfileRestricted(user) ? {...partial, global_name: null, avatar: null} : partial;
}

function isProfileRestricted(user: User): boolean {
	return isInteractionTierEnforced() && !canReachOthers(user);
}

function isDeletedForDisplay(user: User): boolean {
	return (user.flags & UserFlags.DELETED) !== 0n && user.pendingDeletionAt === null && !user.isSystem;
}

function mapUserToOwnPartialResponse(user: User): UserPartialResponse {
	const isBot = user.isBot;
	const avatarHash = stripAvatarForUser(user);
	if (isDeletedForDisplay(user)) {
		return {
			id: user.id.toString(),
			username: DELETED_USER_USERNAME,
			discriminator: DELETED_USER_DISCRIMINATOR.toString().padStart(4, '0'),
			global_name: DELETED_USER_GLOBAL_NAME,
			avatar: null,
			avatar_color: null,
			bot: isBot || undefined,
			system: user.isSystem || undefined,
			flags: 0,
			mention_flags: undefined,
		};
	}
	return {
		id: user.id.toString(),
		username: user.username,
		discriminator: user.discriminator.toString().padStart(4, '0'),
		global_name: user.globalName,
		avatar: avatarHash,
		avatar_color: user.avatarColor,
		bot: isBot || undefined,
		system: user.isSystem || undefined,
		flags: mapUserFlagsToPublicBitfield(user),
		mention_flags: user.mentionFlags ? user.mentionFlags : undefined,
	};
}

export function hasPartialUserFieldsChanged(oldUser: User, newUser: User): boolean {
	const oldPartial = mapUserToPartialResponse(oldUser);
	const newPartial = mapUserToPartialResponse(newUser);
	return (
		oldPartial.username !== newPartial.username ||
		oldPartial.discriminator !== newPartial.discriminator ||
		oldPartial.global_name !== newPartial.global_name ||
		oldPartial.avatar !== newPartial.avatar ||
		oldPartial.avatar_color !== newPartial.avatar_color ||
		oldPartial.bot !== newPartial.bot ||
		oldPartial.system !== newPartial.system ||
		oldPartial.flags !== newPartial.flags ||
		oldPartial.mention_flags !== newPartial.mention_flags
	);
}

export function mapUserToPrivateResponse(user: User): UserPrivateResponse {
	const isStaff = (user.flags & UserFlags.STAFF) !== 0n;
	const partialResponse = mapUserToOwnPartialResponse(user);
	const isActuallyPremium = user.isPremium();
	const traits = Array.from(resolveEffectiveUserTraits(user.traits, isActuallyPremium)).sort();
	const authenticatorTypes = getActiveAuthenticatorTypes(user);
	const accountTier = getAccountTier(user);
	const deprecatedHideFields = deprecatedBadgeHideFields(user, Config.instance.selfHosted);
	return {
		...partialResponse,
		flags: mapUserFlagsToPublicBitfield(user),
		is_staff: isStaff,
		acls: Array.from(user.acls),
		traits,
		email: user.email ?? null,
		email_bounced: user.emailBounced,
		has_verified_phone: false,
		bio: user.bio,
		pronouns: user.pronouns,
		accent_color: user.accentColor,
		timezone: user.timezone,
		timezone_privacy_flags: user.timezonePrivacyFlags,
		banner: stripBannerForUser(user),
		banner_color: user.bannerColor,
		mfa_enabled: authenticatorTypes.length > 0,
		authenticator_types: authenticatorTypes,
		verified: user.emailVerified,
		premium_type: isActuallyPremium ? (user.premiumType ?? UserPremiumTypes.NONE) : UserPremiumTypes.NONE,
		premium_since: isActuallyPremium ? (user.premiumSince?.toISOString() ?? null) : null,
		premium_until: user.effectivePremiumUntil?.toISOString() ?? null,
		premium_will_cancel: user.premiumWillCancel ?? false,
		premium_billing_cycle: user.premiumBillingCycle || null,
		premium_lifetime_sequence: user.premiumLifetimeSequence ?? null,
		premium_grace_ends_at: user.premiumGraceEndsAt?.toISOString() ?? null,
		premium_discriminator: !!(user.premiumFlags & PremiumFlags.DISCRIMINATOR),
		hidden_profile_badges: [...user.hiddenProfileBadges].sort(),
		premium_badge_hidden: deprecatedHideFields.premium_badge_hidden,
		premium_badge_masked: !!(user.premiumFlags & PremiumFlags.BADGE_MASKED),
		premium_badge_timestamp_hidden: !!(user.premiumFlags & PremiumFlags.BADGE_TIMESTAMP_HIDDEN),
		premium_badge_sequence_hidden: deprecatedHideFields.premium_badge_sequence_hidden,
		premium_purchase_disabled: !!(user.premiumFlags & PremiumFlags.PURCHASE_DISABLED),
		premium_enabled_override: !!(user.premiumFlags & PremiumFlags.ENABLED_OVERRIDE),
		premium_perks_disabled: !!(user.premiumFlags & PremiumFlags.PERKS_DISABLED),
		password_last_changed_at: user.passwordLastChangedAt?.toISOString() ?? null,
		last_voice_activity_sharing_change_at: user.lastVoiceActivitySharingChangeAt?.toISOString() ?? null,
		required_actions: [],
		account_limited: isAccountLimited(user),
		nsfw_allowed: canUserAccessNsfwContent(user),
		has_dismissed_premium_onboarding: isActuallyPremium && user.premiumOnboardingDismissedAt != null,
		has_ever_purchased: user.hasEverPurchased,
		has_unread_gift_inventory:
			user.giftInventoryServerSeq != null &&
			(user.giftInventoryClientSeq == null || user.giftInventoryClientSeq < user.giftInventoryServerSeq),
		unread_gift_inventory_count:
			user.giftInventoryServerSeq != null ? user.giftInventoryServerSeq - (user.giftInventoryClientSeq ?? 0) : 0,
		age_verified_adult: !!(user.flags & UserFlags.AGE_VERIFIED_ADULT) || undefined,
		terms_agreed_at: user.termsAgreedAt?.toISOString() ?? null,
		privacy_agreed_at: user.privacyAgreedAt?.toISOString() ?? null,
		claimed: accountTier !== AccountTiers.UNCLAIMED,
		account_tier: accountTier,
		verification_need: getVerificationNeed(user),
		has_password: user.passwordHash !== null,
		date_of_birth_required: isDateOfBirthMissing(user),
		profile_restricted: isProfileRestricted(user),
		pending_bulk_message_deletion:
			user.pendingBulkMessageDeletionAt != null
				? {
						scheduled_at: user.pendingBulkMessageDeletionAt.toISOString(),
						channel_count: user.pendingBulkMessageDeletionChannelCount ?? 0,
						message_count: user.pendingBulkMessageDeletionMessageCount ?? 0,
					}
				: null,
	};
}

export function mapUserToProfileResponse(
	user: User,
	options?: {restrictProfile?: boolean; viewerIsSelf?: boolean},
): UserProfileResponse {
	if (isProfileHidden(user) || (isProfileRestricted(user) && !options?.viewerIsSelf)) {
		return {bio: null, pronouns: null, banner: null, banner_color: null, accent_color: null};
	}
	if (options?.restrictProfile) {
		return {
			bio: null,
			pronouns: null,
			banner: stripBannerForUser(user),
			banner_color: user.bannerColor,
			accent_color: user.accentColor,
		};
	}
	return {
		bio: user.bio,
		pronouns: user.pronouns,
		banner: stripBannerForUser(user),
		banner_color: user.bannerColor,
		accent_color: user.accentColor,
	};
}

export function mapUserToOAuthResponse(
	user: User,
	opts?: {
		includeEmail?: boolean;
	},
) {
	const includeEmail = opts?.includeEmail && !!user.email;
	return {
		sub: user.id.toString(),
		id: user.id.toString(),
		username: user.username,
		discriminator: user.discriminator.toString().padStart(4, '0'),
		avatar: stripAvatarForUser(user),
		verified: includeEmail ? (user.emailVerified ?? false) : undefined,
		email: includeEmail ? (user.email ?? null) : null,
		flags: mapUserFlagsToPublicBitfield(user),
		global_name: user.globalName ?? null,
		bot: user.isBot,
		system: user.isSystem,
		avatar_color: user.avatarColor,
	};
}

export function mapGuildMemberToProfileResponse(
	guildMember: GuildMember | null | undefined,
	options?: {restrictProfile?: boolean; hidden?: boolean},
): UserProfileResponse | null {
	if (!guildMember) return null;
	if (options?.hidden) {
		return {bio: null, pronouns: null, banner: null, accent_color: null};
	}
	if (options?.restrictProfile) {
		return {
			bio: null,
			pronouns: null,
			banner: guildMember.isPremiumSanitized ? null : guildMember.bannerHash,
			accent_color: guildMember.accentColor,
		};
	}
	return {
		bio: guildMember.bio,
		pronouns: guildMember.pronouns,
		banner: guildMember.isPremiumSanitized ? null : guildMember.bannerHash,
		accent_color: guildMember.accentColor,
	};
}

interface GuildFolderResponse {
	id: number;
	name: string | null;
	color: number | null;
	flags: number;
	icon: GuildFolderIcon;
	guild_ids: Array<string>;
}

export function mapUserSettingsToResponse(params: {settings: UserSettings}): UserSettingsResponse {
	const {settings} = params;
	let guildFolders: Array<GuildFolderResponse>;
	if (settings.guildFolders != null && settings.guildFolders.length > 0) {
		guildFolders = settings.guildFolders.map((folder) => ({
			id: folder.folderId,
			name: folder.name,
			color: folder.color,
			flags: folder.flags,
			icon: folder.icon,
			guild_ids: folder.guildIds.map(String),
		}));
	} else if (settings.guildPositions != null && settings.guildPositions.length > 0) {
		guildFolders = [
			{
				id: UNCATEGORIZED_FOLDER_ID,
				name: null,
				color: null,
				flags: 0,
				icon: DEFAULT_GUILD_FOLDER_ICON,
				guild_ids: settings.guildPositions.map(String),
			},
		];
	} else {
		guildFolders = [];
	}
	return {
		status: settings.status,
		status_resets_at: settings.statusResetsAt?.toISOString() ?? null,
		status_resets_to: settings.statusResetsTo,
		theme: settings.theme,
		locale: settings.locale,
		restricted_guilds: [...settings.restrictedGuilds].map(String),
		bot_restricted_guilds: [...settings.botRestrictedGuilds].map(String),
		default_guilds_restricted: settings.defaultGuildsRestricted,
		bot_default_guilds_restricted: settings.botDefaultGuildsRestricted,
		inline_attachment_media: settings.inlineAttachmentMedia,
		inline_embed_media: settings.inlineEmbedMedia,
		gif_auto_play: settings.gifAutoPlay,
		render_embeds: settings.renderEmbeds,
		render_reactions: settings.renderReactions,
		animate_emoji: settings.animateEmoji,
		animate_stickers: settings.animateStickers,
		render_spoilers: settings.renderSpoilers,
		message_display_compact: settings.compactMessageDisplay,
		friend_source_flags: settings.friendSourceFlags,
		incoming_call_flags: settings.incomingCallFlags,
		group_dm_add_permission_flags: settings.groupDmAddPermissionFlags,
		guild_folders: guildFolders,
		custom_status: settings.customStatus
			? {
					text: settings.customStatus.text,
					expires_at: settings.customStatus.expiresAt?.toISOString(),
					emoji_id: settings.customStatus.emojiId?.toString(),
					emoji_name: settings.customStatus.emojiName,
					emoji_animated: settings.customStatus.emojiAnimated,
				}
			: null,
		afk_timeout: settings.afkTimeout,
		time_format: settings.timeFormat,
		developer_mode: settings.developerMode,
		trusted_domains: [...settings.trustedDomains],
		default_hide_muted_channels: settings.defaultHideMutedChannels,
		sensitive_content_friend_dm_filter: settings.sensitiveContentFriendDmFilter,
		sensitive_content_non_friend_dm_filter: settings.sensitiveContentNonFriendDmFilter,
		sensitive_content_guild_filter: settings.sensitiveContentGuildFilter as 0 | 1,
		allow_mature_content_on_ios: settings.allowMatureContentOnIos,
		suppress_unprivileged_self_mentions: settings.suppressUnprivilegedSelfMentions,
		suppress_unprivileged_self_mentions_bypass_user_ids: sortUserIds(
			settings.suppressUnprivilegedSelfMentionBypassUserIds,
		),
		staff_dm_access_user_ids: sortUserIds(settings.staffDmAccessUserIds),
		synced_preferences: settings.syncedPreferences,
		profile_privacy: settings.profilePrivacy,
		default_share_voice_activity: settings.defaultShareVoiceActivity,
		privacy_setup_version: settings.privacySetupVersion,
		privacy_setup_completed_at: settings.privacySetupCompletedAt?.toISOString() ?? null,
	};
}

export async function mapRelationshipToResponse(params: {
	relationship: Relationship;
	userPartialResolver: (userId: UserID) => Promise<UserPartialResponse>;
	inverseRelationshipResolver?: (relationship: Relationship) => Promise<Relationship | null>;
}): Promise<RelationshipResponse> {
	const {relationship, userPartialResolver, inverseRelationshipResolver} = params;
	const [userPartial, inverse] = await Promise.all([
		userPartialResolver(relationship.targetUserId),
		inverseRelationshipResolver ? inverseRelationshipResolver(relationship) : Promise.resolve(null),
	]);
	return {
		id: relationship.targetUserId.toString(),
		type: relationship.type,
		user: userPartial,
		since: relationship.since?.toISOString(),
		nickname: relationship.nickname,
		share_voice_activity: relationship.shareVoiceActivity,
		friend_shares_voice_activity: inverse?.shareVoiceActivity ?? true,
	};
}

const mapMuteConfigToResponse = (
	muteConfig: MuteConfiguration | null,
): {
	end_time: string | null;
	selected_time_window: number;
} | null =>
	muteConfig
		? {
				end_time: muteConfig.endTime?.toISOString() ?? null,
				selected_time_window: muteConfig.selectedTimeWindow ?? 0,
			}
		: null;

function mapChannelOverrideToResponse(
	override: GuildChannelOverride,
	withFlags: boolean,
): {
	collapsed: boolean;
	message_notifications: ChannelMessageNotifications;
	muted: boolean;
	mute_config: {
		end_time: string | null;
		selected_time_window: number;
	} | null;
	unread_badges: ChannelMessageNotifications | null;
	flags?: number;
} {
	return {
		collapsed: override.collapsed,
		message_notifications: override.messageNotifications ?? 0,
		muted: override.muted,
		mute_config: mapMuteConfigToResponse(override.muteConfig),
		unread_badges: override.unreadBadges ?? null,
		...(withFlags && override.flags ? {flags: override.flags} : {}),
	};
}

export interface UserGuildSettingsThreadView {
	flags: boolean;
	hiddenChannelIds?: ReadonlySet<string>;
}

export function mapUserGuildSettingsToResponse(
	settings: UserGuildSettings,
	threadView?: UserGuildSettingsThreadView,
): UserGuildSettingsResponse {
	const hidden = threadView?.hiddenChannelIds;
	const overrides = hidden?.size
		? Array.from(settings.channelOverrides.entries()).filter(([channelId]) => !hidden.has(channelId.toString()))
		: Array.from(settings.channelOverrides.entries());
	return {
		guild_id: settings.guildId === createGuildID(0n) ? null : settings.guildId.toString(),
		message_notifications: settings.messageNotifications ?? 0,
		muted: settings.muted,
		mute_config: mapMuteConfigToResponse(settings.muteConfig),
		mobile_push: settings.mobilePush,
		suppress_everyone: settings.suppressEveryone,
		suppress_roles: settings.suppressRoles,
		hide_muted_channels: settings.hideMutedChannels,
		channel_overrides: overrides.length
			? Object.fromEntries(
					overrides.map(([channelId, override]) => [
						channelId.toString(),
						mapChannelOverrideToResponse(override, threadView?.flags === true),
					]),
				)
			: null,
		unread_badges: settings.unreadBadges ?? null,
		version: settings.version,
	};
}

export function mapWebAuthnCredentialToResponse(
	credential: WebAuthnCredential,
	legacyRpId: string,
): WebAuthnCredentialResponse {
	return {
		id: credential.credentialId,
		name: credential.name,
		created_at: credential.createdAt.toISOString(),
		last_used_at: credential.lastUsedAt?.toISOString() ?? null,
		rp_id: credential.rpId ?? legacyRpId,
	};
}

export async function dispatchUserUpdate(
	gateway: Pick<IGatewayService, 'dispatchPresence'>,
	user: User,
): Promise<void> {
	await gateway.dispatchPresence({userId: user.id, event: 'USER_UPDATE', data: mapUserToPrivateResponse(user)});
}