371 lines
11 KiB
TypeScript
371 lines
11 KiB
TypeScript
/*
|
|
* Copyright (C) 2026 Fluxer Contributors
|
|
*
|
|
* This file is part of Fluxer.
|
|
*
|
|
* Fluxer is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Fluxer is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
import type {ChannelID, GuildID} from '~/BrandedTypes';
|
|
import {InviteTypes} from '~/Constants';
|
|
import {ChannelPartialResponse} from '~/channel/ChannelModel';
|
|
import {UnknownInviteError} from '~/Errors';
|
|
import {UnknownPackError} from '~/errors/UnknownPackError';
|
|
import {GuildPartialResponse} from '~/guild/GuildModel';
|
|
import type {IGatewayService} from '~/infrastructure/IGatewayService';
|
|
import type {UserCacheService} from '~/infrastructure/UserCacheService';
|
|
import type {Channel, Invite} from '~/Models';
|
|
import type {RequestCache} from '~/middleware/RequestCacheMiddleware';
|
|
import {mapPackToSummary} from '~/pack/PackModel';
|
|
import type {PackRepository} from '~/pack/PackRepository';
|
|
import {z} from '~/Schema';
|
|
import {getCachedUserPartialResponse, getCachedUserPartialResponses} from '~/user/UserCacheHelpers';
|
|
import {UserPartialResponse} from '~/user/UserModel';
|
|
|
|
export const GuildInviteResponse = z.object({
|
|
code: z.string(),
|
|
type: z.literal(InviteTypes.GUILD),
|
|
guild: GuildPartialResponse,
|
|
channel: z.lazy(() => ChannelPartialResponse),
|
|
inviter: z.lazy(() => UserPartialResponse).nullish(),
|
|
member_count: z.number().int(),
|
|
presence_count: z.number().int(),
|
|
expires_at: z.iso.datetime().nullish(),
|
|
temporary: z.boolean(),
|
|
});
|
|
export type GuildInviteResponse = z.infer<typeof GuildInviteResponse>;
|
|
|
|
export const GroupDmInviteResponse = z.object({
|
|
code: z.string(),
|
|
type: z.literal(InviteTypes.GROUP_DM),
|
|
channel: z.lazy(() => ChannelPartialResponse),
|
|
inviter: z.lazy(() => UserPartialResponse).nullish(),
|
|
member_count: z.number().int(),
|
|
expires_at: z.iso.datetime().nullish(),
|
|
temporary: z.boolean(),
|
|
});
|
|
export type GroupDmInviteResponse = z.infer<typeof GroupDmInviteResponse>;
|
|
|
|
const PackInfoResponse = z.object({
|
|
id: z.string(),
|
|
name: z.string(),
|
|
description: z.string().nullish(),
|
|
type: z.enum(['emoji', 'sticker']),
|
|
creator_id: z.string(),
|
|
created_at: z.iso.datetime(),
|
|
updated_at: z.iso.datetime(),
|
|
creator: z.lazy(() => UserPartialResponse),
|
|
});
|
|
|
|
export const PackInviteResponse = z.object({
|
|
code: z.string(),
|
|
type: z.union([z.literal(InviteTypes.EMOJI_PACK), z.literal(InviteTypes.STICKER_PACK)]),
|
|
pack: PackInfoResponse,
|
|
inviter: z.lazy(() => UserPartialResponse).nullish(),
|
|
expires_at: z.iso.datetime().nullish(),
|
|
temporary: z.boolean(),
|
|
});
|
|
export type PackInviteResponse = z.infer<typeof PackInviteResponse>;
|
|
|
|
export const PackInviteMetadataResponse = z.object({
|
|
...PackInviteResponse.shape,
|
|
created_at: z.iso.datetime(),
|
|
uses: z.number().int(),
|
|
max_uses: z.number().int(),
|
|
});
|
|
export type PackInviteMetadataResponse = z.infer<typeof PackInviteMetadataResponse>;
|
|
|
|
export const GuildInviteMetadataResponse = z.object({
|
|
...GuildInviteResponse.shape,
|
|
created_at: z.iso.datetime(),
|
|
uses: z.number().int(),
|
|
max_uses: z.number().int(),
|
|
});
|
|
export type GuildInviteMetadataResponse = z.infer<typeof GuildInviteMetadataResponse>;
|
|
|
|
export const GroupDmInviteMetadataResponse = z.object({
|
|
...GroupDmInviteResponse.shape,
|
|
created_at: z.iso.datetime(),
|
|
uses: z.number().int(),
|
|
max_uses: z.number().int(),
|
|
});
|
|
export type GroupDmInviteMetadataResponse = z.infer<typeof GroupDmInviteMetadataResponse>;
|
|
|
|
interface MapInviteToGuildInviteResponseParams {
|
|
invite: Invite;
|
|
userCacheService: UserCacheService;
|
|
requestCache: RequestCache;
|
|
getChannelResponse: (channelId: ChannelID) => Promise<ChannelPartialResponse>;
|
|
getGuildResponse: (guildId: GuildID) => Promise<GuildPartialResponse>;
|
|
getGuildCounts: (guildId: GuildID) => Promise<{memberCount: number; presenceCount: number}>;
|
|
gatewayService: IGatewayService;
|
|
}
|
|
|
|
interface MapInviteToGuildInviteMetadataResponseParams {
|
|
invite: Invite;
|
|
userCacheService: UserCacheService;
|
|
requestCache: RequestCache;
|
|
getChannelResponse: (channelId: ChannelID) => Promise<ChannelPartialResponse>;
|
|
getGuildResponse: (guildId: GuildID) => Promise<GuildPartialResponse>;
|
|
getGuildCounts: (guildId: GuildID) => Promise<{memberCount: number; presenceCount: number}>;
|
|
gatewayService: IGatewayService;
|
|
}
|
|
|
|
interface MapInviteToGroupDmInviteResponseParams {
|
|
invite: Invite;
|
|
userCacheService: UserCacheService;
|
|
requestCache: RequestCache;
|
|
getChannelResponse: (channelId: ChannelID) => Promise<ChannelPartialResponse>;
|
|
getChannelSystem: (channelId: ChannelID) => Promise<Channel | null>;
|
|
getChannelMemberCount: (channelId: ChannelID) => Promise<number>;
|
|
}
|
|
|
|
interface MapInviteToGroupDmInviteMetadataResponseParams {
|
|
invite: Invite;
|
|
userCacheService: UserCacheService;
|
|
requestCache: RequestCache;
|
|
getChannelResponse: (channelId: ChannelID) => Promise<ChannelPartialResponse>;
|
|
getChannelSystem: (channelId: ChannelID) => Promise<Channel | null>;
|
|
getChannelMemberCount: (channelId: ChannelID) => Promise<number>;
|
|
}
|
|
|
|
export const mapInviteToGuildInviteResponse = async ({
|
|
invite,
|
|
userCacheService,
|
|
requestCache,
|
|
getChannelResponse,
|
|
getGuildResponse,
|
|
getGuildCounts,
|
|
gatewayService,
|
|
}: MapInviteToGuildInviteResponseParams): Promise<GuildInviteResponse> => {
|
|
if (!invite.guildId) {
|
|
throw new UnknownInviteError();
|
|
}
|
|
|
|
let channelId = invite.channelId;
|
|
if (!channelId) {
|
|
const resolvedChannelId = await gatewayService.getFirstViewableTextChannel(invite.guildId);
|
|
if (!resolvedChannelId) {
|
|
throw new UnknownInviteError();
|
|
}
|
|
channelId = resolvedChannelId;
|
|
}
|
|
|
|
const [channel, guild, inviter, counts] = await Promise.all([
|
|
getChannelResponse(channelId),
|
|
getGuildResponse(invite.guildId),
|
|
invite.inviterId
|
|
? getCachedUserPartialResponse({
|
|
userId: invite.inviterId,
|
|
userCacheService,
|
|
requestCache,
|
|
})
|
|
: null,
|
|
getGuildCounts(invite.guildId),
|
|
]);
|
|
|
|
const expiresAt = invite.maxAge > 0 ? new Date(invite.createdAt.getTime() + invite.maxAge * 1000) : null;
|
|
|
|
return {
|
|
code: invite.code,
|
|
type: InviteTypes.GUILD,
|
|
guild,
|
|
channel,
|
|
inviter,
|
|
member_count: counts.memberCount,
|
|
presence_count: counts.presenceCount,
|
|
expires_at: expiresAt?.toISOString() ?? null,
|
|
temporary: invite.temporary,
|
|
};
|
|
};
|
|
|
|
export const mapInviteToGuildInviteMetadataResponse = async ({
|
|
invite,
|
|
userCacheService,
|
|
requestCache,
|
|
getChannelResponse,
|
|
getGuildResponse,
|
|
getGuildCounts,
|
|
gatewayService,
|
|
}: MapInviteToGuildInviteMetadataResponseParams): Promise<GuildInviteMetadataResponse> => {
|
|
const baseResponse = await mapInviteToGuildInviteResponse({
|
|
invite,
|
|
userCacheService,
|
|
requestCache,
|
|
getChannelResponse,
|
|
getGuildResponse,
|
|
getGuildCounts,
|
|
gatewayService,
|
|
});
|
|
|
|
return {
|
|
...baseResponse,
|
|
created_at: invite.createdAt.toISOString(),
|
|
uses: invite.uses,
|
|
max_uses: invite.maxUses,
|
|
};
|
|
};
|
|
|
|
export const mapInviteToGroupDmInviteResponse = async ({
|
|
invite,
|
|
userCacheService,
|
|
requestCache,
|
|
getChannelResponse,
|
|
getChannelSystem,
|
|
getChannelMemberCount,
|
|
}: MapInviteToGroupDmInviteResponseParams): Promise<GroupDmInviteResponse> => {
|
|
if (!invite.channelId) {
|
|
throw new UnknownInviteError();
|
|
}
|
|
|
|
const [channel, inviter, memberCount, channelSystem] = await Promise.all([
|
|
getChannelResponse(invite.channelId),
|
|
invite.inviterId
|
|
? getCachedUserPartialResponse({
|
|
userId: invite.inviterId,
|
|
userCacheService,
|
|
requestCache,
|
|
})
|
|
: null,
|
|
getChannelMemberCount(invite.channelId),
|
|
getChannelSystem(invite.channelId),
|
|
]);
|
|
if (!channelSystem) {
|
|
throw new UnknownInviteError();
|
|
}
|
|
|
|
const recipientIds = Array.from(channelSystem.recipientIds);
|
|
const recipientPartials = await getCachedUserPartialResponses({
|
|
userIds: recipientIds,
|
|
userCacheService,
|
|
requestCache,
|
|
});
|
|
|
|
const recipients = recipientIds.map((recipientId) => {
|
|
const recipientPartial = recipientPartials.get(recipientId);
|
|
if (!recipientPartial) {
|
|
throw new UnknownInviteError();
|
|
}
|
|
return {username: recipientPartial.username};
|
|
});
|
|
const channelWithRecipients = {...channel, recipients};
|
|
|
|
const expiresAt = invite.maxAge > 0 ? new Date(invite.createdAt.getTime() + invite.maxAge * 1000) : null;
|
|
|
|
return {
|
|
code: invite.code,
|
|
type: InviteTypes.GROUP_DM,
|
|
channel: channelWithRecipients,
|
|
inviter,
|
|
member_count: memberCount,
|
|
expires_at: expiresAt?.toISOString() ?? null,
|
|
temporary: invite.temporary,
|
|
};
|
|
};
|
|
|
|
export const mapInviteToGroupDmInviteMetadataResponse = async ({
|
|
invite,
|
|
userCacheService,
|
|
requestCache,
|
|
getChannelResponse,
|
|
getChannelSystem,
|
|
getChannelMemberCount,
|
|
}: MapInviteToGroupDmInviteMetadataResponseParams): Promise<GroupDmInviteMetadataResponse> => {
|
|
const baseResponse = await mapInviteToGroupDmInviteResponse({
|
|
invite,
|
|
userCacheService,
|
|
requestCache,
|
|
getChannelResponse,
|
|
getChannelSystem,
|
|
getChannelMemberCount,
|
|
});
|
|
|
|
return {
|
|
...baseResponse,
|
|
created_at: invite.createdAt.toISOString(),
|
|
uses: invite.uses,
|
|
max_uses: invite.maxUses,
|
|
};
|
|
};
|
|
|
|
interface MapInviteToPackInviteResponseParams {
|
|
invite: Invite;
|
|
userCacheService: UserCacheService;
|
|
requestCache: RequestCache;
|
|
packRepository: PackRepository;
|
|
}
|
|
|
|
const buildPackInviteBase = async ({
|
|
invite,
|
|
userCacheService,
|
|
requestCache,
|
|
packRepository,
|
|
}: MapInviteToPackInviteResponseParams): Promise<PackInviteResponse> => {
|
|
if (!invite.guildId) {
|
|
throw new UnknownPackError();
|
|
}
|
|
|
|
const pack = await packRepository.getPack(invite.guildId);
|
|
if (!pack) {
|
|
throw new UnknownPackError();
|
|
}
|
|
|
|
const creator = await getCachedUserPartialResponse({
|
|
userId: pack.creatorId,
|
|
userCacheService,
|
|
requestCache,
|
|
});
|
|
|
|
const inviter = invite.inviterId
|
|
? await getCachedUserPartialResponse({
|
|
userId: invite.inviterId,
|
|
userCacheService,
|
|
requestCache,
|
|
})
|
|
: null;
|
|
|
|
const expiresAt = invite.maxAge > 0 ? new Date(invite.createdAt.getTime() + invite.maxAge * 1000) : null;
|
|
|
|
return {
|
|
code: invite.code,
|
|
type: invite.type as typeof InviteTypes.EMOJI_PACK | typeof InviteTypes.STICKER_PACK,
|
|
pack: {
|
|
...mapPackToSummary(pack),
|
|
creator,
|
|
},
|
|
inviter,
|
|
expires_at: expiresAt?.toISOString() ?? null,
|
|
temporary: invite.temporary,
|
|
};
|
|
};
|
|
|
|
export const mapInviteToPackInviteResponse = async (
|
|
params: MapInviteToPackInviteResponseParams,
|
|
): Promise<PackInviteResponse> => {
|
|
return buildPackInviteBase(params);
|
|
};
|
|
|
|
export const mapInviteToPackInviteMetadataResponse = async (
|
|
params: MapInviteToPackInviteResponseParams,
|
|
): Promise<PackInviteMetadataResponse> => {
|
|
const baseResponse = await buildPackInviteBase(params);
|
|
|
|
return {
|
|
...baseResponse,
|
|
created_at: params.invite.createdAt.toISOString(),
|
|
uses: params.invite.uses,
|
|
max_uses: params.invite.maxUses,
|
|
};
|
|
};
|