A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// SPDX-License-Identifier: AGPL-3.0-or-later
import type {ApiContext} from '@app/api/ApiContext';
import type {AdminAuditService} from '@app/api/admin/services/AdminAuditService';
import {type ApplicationID, createApplicationID, createUserID, type GuildID, type UserID} from '@app/api/BrandedTypes';
import type {GuildRepository} from '@app/api/guild/repositories/GuildRepository';
import type {Application} from '@app/api/models/Application';
import type {User} from '@app/api/models/User';
import type {ApplicationRepository} from '@app/api/oauth/repositories/ApplicationRepository';
import {UnknownGuildError} from '@fluxer/errors/src/domains/guild/UnknownGuildError';
import {UnknownApplicationError} from '@fluxer/errors/src/domains/oauth/UnknownApplicationError';
import type {
ApplicationAdminResponse,
ListApplicationsResponse,
LookupApplicationResponse,
TransferApplicationOwnershipRequest,
} from '@fluxer/schema/src/domains/admin/AdminApplicationSchemas';
import {compareSnowflakes} from '@fluxer/snowflake/src/SnowflakeComparison';
const BATCH_SIZE = 100;
interface AdminApplicationServiceDeps {
apiContext: ApiContext;
applicationRepository: ApplicationRepository;
auditService: AdminAuditService;
guildRepository: GuildRepository;
}
interface UserDisplay {
username: string | null;
global_name: string | null;
discriminator: string | null;
}
export class AdminApplicationService {
constructor(private readonly deps: AdminApplicationServiceDeps) {}
async lookupApplication(applicationId: ApplicationID): Promise<LookupApplicationResponse> {
const {applicationRepository} = this.deps;
const application = await applicationRepository.getApplication(applicationId);
if (!application) {
return {application: null};
}
const userDisplays = await this.loadUserDisplays([application.ownerUserId, application.botUserId]);
return {
application: this.toResponse(application, userDisplays),
};
}
async listUserApplications(ownerUserId: UserID): Promise<ListApplicationsResponse> {
const {applicationRepository} = this.deps;
const {users: userRepository} = this.deps.apiContext.services;
const owner = await userRepository.findUniqueAssert(ownerUserId);
const applications = await applicationRepository.listApplicationsByOwner(ownerUserId);
const ownerDisplay: UserDisplay = {
username: owner.username,
global_name: owner.globalName ?? null,
discriminator: String(owner.discriminator).padStart(4, '0'),
};
const botUserIds = applications.map((app) => app.botUserId).filter((id): id is UserID => id !== null);
const botDisplays = await this.loadUserDisplays(botUserIds);
const displayMap = new Map<string, UserDisplay>();
displayMap.set(ownerUserId.toString(), ownerDisplay);
for (const [id, display] of botDisplays.entries()) {
displayMap.set(id, display);
}
return {
applications: applications.map((app) => this.toResponse(app, displayMap)),
};
}
async listGuildApplications(guildId: GuildID): Promise<ListApplicationsResponse> {
const {applicationRepository, guildRepository} = this.deps;
const guild = await guildRepository.findUnique(guildId);
if (!guild) {
throw new UnknownGuildError();
}
const applications: Array<Application> = [];
let afterUserId: UserID | undefined;
while (true) {
const members = await guildRepository.listMembersPaginated(guildId, BATCH_SIZE, afterUserId);
const pageApplications = await applicationRepository.listApplicationsByIds(
members.map((member) => createApplicationID(BigInt(member.userId.toString()))),
);
const pageMatches = pageApplications
.filter((application) => application.botUserId?.toString() === application.applicationId.toString())
.sort((a, b) => compareSnowflakes(a.applicationId, b.applicationId));
applications.push(...pageMatches);
const lastMember = members.at(-1);
if (!lastMember || members.length < BATCH_SIZE) break;
afterUserId = lastMember.userId;
}
const userDisplays = await this.loadUserDisplays(
applications.flatMap((application) => [application.ownerUserId, application.botUserId]),
);
return {
applications: applications.map((application) => this.toResponse(application, userDisplays)),
};
}
async transferApplicationOwnership(
applicationId: ApplicationID,
data: TransferApplicationOwnershipRequest,
adminUserId: UserID,
auditLogReason: string | null,
) {
const {applicationRepository, auditService} = this.deps;
const {users: userRepository} = this.deps.apiContext.services;
const application = await applicationRepository.getApplication(applicationId);
if (!application) {
throw new UnknownApplicationError();
}
const newOwnerId = createUserID(data.new_owner_id);
await userRepository.findUniqueAssert(newOwnerId);
const oldOwnerId = application.ownerUserId;
const oldRow = application.toRow();
const updatedApplication = await applicationRepository.upsertApplication(
{...oldRow, owner_user_id: newOwnerId},
oldRow,
);
await auditService.createAuditLog({
adminUserId,
targetType: 'application',
targetId: BigInt(applicationId),
action: 'transfer_ownership',
auditLogReason,
metadata: new Map([
['old_owner_id', oldOwnerId.toString()],
['new_owner_id', newOwnerId.toString()],
]),
});
const userDisplays = await this.loadUserDisplays([updatedApplication.ownerUserId, updatedApplication.botUserId]);
return {
application: this.toResponse(updatedApplication, userDisplays),
};
}
private async loadUserDisplays(userIds: ReadonlyArray<UserID | null>): Promise<Map<string, UserDisplay>> {
const {users: userRepository} = this.deps.apiContext.services;
const uniqueIds = new Set<string>();
const nonNullIds: Array<UserID> = [];
for (const userId of userIds) {
if (userId === null) continue;
const key = userId.toString();
if (uniqueIds.has(key)) continue;
uniqueIds.add(key);
nonNullIds.push(userId);
}
const users: Array<User | null> = [];
for (let i = 0; i < nonNullIds.length; i += BATCH_SIZE) {
const chunk = nonNullIds.slice(i, i + BATCH_SIZE);
users.push(...(await Promise.all(chunk.map((id) => userRepository.findUnique(id)))));
}
const map = new Map<string, UserDisplay>();
for (let i = 0; i < nonNullIds.length; i += 1) {
const id = nonNullIds[i];
if (!id) continue;
const user = users[i];
if (!user) continue;
map.set(id.toString(), {
username: user.username,
global_name: user.globalName ?? null,
discriminator: String(user.discriminator).padStart(4, '0'),
});
}
return map;
}
private toResponse(application: Application, userDisplays: Map<string, UserDisplay>): ApplicationAdminResponse {
const emptyDisplay: UserDisplay = {username: null, global_name: null, discriminator: null};
const ownerDisplay = userDisplays.get(application.ownerUserId.toString()) ?? emptyDisplay;
const botDisplay = application.botUserId
? (userDisplays.get(application.botUserId.toString()) ?? emptyDisplay)
: emptyDisplay;
return {
id: application.applicationId.toString(),
name: application.name,
owner_user_id: application.ownerUserId.toString(),
owner_username: ownerDisplay.username,
owner_global_name: ownerDisplay.global_name,
owner_discriminator: ownerDisplay.discriminator,
bot_user_id: application.botUserId?.toString() ?? null,
bot_username: botDisplay.username,
bot_global_name: botDisplay.global_name,
bot_discriminator: botDisplay.discriminator,
bot_is_public: application.botIsPublic,
bot_require_code_grant: application.botRequireCodeGrant,
oauth2_redirect_uris: Array.from(application.oauth2RedirectUris),
has_client_secret: application.clientSecretHash !== null,
has_bot_token: application.botTokenHash !== null,
bot_token_preview: application.botTokenPreview,
bot_token_created_at: application.botTokenCreatedAt?.toISOString() ?? null,
client_secret_created_at: application.clientSecretCreatedAt?.toISOString() ?? null,
version: application.version,
};
}
}