Skip to content

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

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

import {GuildDiscoveryRepository} from '@app/api/guild/repositories/GuildDiscoveryRepository';
import type {IAuditLogSearchService} from '@app/api/search/IAuditLogSearchService';
import type {IGuildMemberSearchService} from '@app/api/search/IGuildMemberSearchService';
import type {IGuildSearchService} from '@app/api/search/IGuildSearchService';
import type {IMessageSearchService} from '@app/api/search/IMessageSearchService';
import type {IReportSearchService} from '@app/api/search/IReportSearchService';
import type {ISearchProvider} from '@app/api/search/ISearchProvider';
import type {IThreadSearchService} from '@app/api/search/IThreadSearchService';
import type {IUserSearchService} from '@app/api/search/IUserSearchService';
import {
	AuditLogSearchService,
	GuildMemberSearchService,
	GuildSearchService,
	MessageSearchService,
	ReportSearchService,
	UserSearchService,
} from '@app/api/search/SearchServices';
import {ThreadSearchIndex} from '@app/api/search/thread/ThreadSearchIndex';
import type {SearchOptions, SearchResult} from '@fluxer/schema/src/contracts/search/SearchAdapterTypes';
import type {
	AuditLogSearchFilters,
	GuildMemberSearchFilters,
	GuildSearchFilters,
	MessageSearchFilters,
	ReportSearchFilters,
	SearchableAuditLog,
	SearchableGuild,
	SearchableGuildMember,
	SearchableMessage,
	SearchableReport,
	SearchableThread,
	SearchableUser,
	ThreadSearchCursor,
	ThreadSearchFilters,
	UserSearchFilters,
} from '@fluxer/schema/src/contracts/search/SearchDocumentTypes';

interface SearchableDocument {
	id: string;
}

type Matcher<TDocument, TFilters> = (doc: TDocument, filters: TFilters) => boolean;
type TextCollector<TDocument, TFilters> = (doc: TDocument, filters: TFilters) => Array<string | null>;
type Sorter<TDocument, TFilters> = (left: TDocument, right: TDocument, filters: TFilters, query: string) => number;

const DEFAULT_LIMIT = 25;

function normalize(value: string | null | undefined): string {
	return (value ?? '').toLowerCase();
}

function containsText(value: string | null | undefined, query: string): boolean {
	const normalizedQuery = normalize(query).trim();
	if (normalizedQuery.length === 0) {
		return true;
	}
	const normalizedValue = normalize(value);
	if (normalizedValue.includes(normalizedQuery)) {
		return true;
	}
	const terms = normalizedQuery.split(/\s+/).filter((term) => term.length > 0);
	return terms.length > 0 && terms.every((term) => normalizedValue.includes(term));
}

function arrayIncludesAny(values: ReadonlyArray<string>, needles: ReadonlyArray<string> | undefined): boolean {
	return !needles || needles.length === 0 || needles.some((needle) => values.includes(needle));
}

function arrayExcludesAll(values: ReadonlyArray<string>, needles: ReadonlyArray<string> | undefined): boolean {
	return !needles || needles.every((needle) => !values.includes(needle));
}

function stringArrayContainsText(values: ReadonlyArray<string>, query: string): boolean {
	return values.some((value) => containsText(value, query));
}

function paginate<T>(items: Array<T>, options?: SearchOptions): Array<T> {
	const limit = options?.limit ?? options?.hitsPerPage ?? DEFAULT_LIMIT;
	const offset = options?.offset ?? ((options?.page ?? 1) - 1) * limit;
	return items.slice(offset, offset + limit);
}

function relevanceScore(values: Array<string | null>, query: string): number {
	const normalizedQuery = normalize(query).trim();
	if (!normalizedQuery) {
		return 0;
	}
	let score = 0;
	for (const value of values) {
		const text = normalize(value);
		if (text === normalizedQuery) {
			score += 100;
		}
		let index = text.indexOf(normalizedQuery);
		while (index !== -1) {
			score += 1;
			index = text.indexOf(normalizedQuery, index + normalizedQuery.length);
		}
	}
	return score;
}

class InMemorySearchAdapter<TFilters, TDocument extends SearchableDocument> {
	private readonly docs = new Map<string, TDocument>();

	constructor(
		private readonly matchesFilters: Matcher<TDocument, TFilters>,
		private readonly collectText: TextCollector<TDocument, TFilters>,
		private readonly sortDocuments: Sorter<TDocument, TFilters>,
	) {}

	async initialize(): Promise<void> {}

	async shutdown(): Promise<void> {
		this.docs.clear();
	}

	isAvailable(): boolean {
		return true;
	}

	async indexDocument(doc: TDocument): Promise<void> {
		this.docs.set(doc.id, doc);
	}

	async indexDocuments(docs: Array<TDocument>): Promise<void> {
		for (const doc of docs) {
			this.docs.set(doc.id, doc);
		}
	}

	async updateDocument(doc: TDocument): Promise<void> {
		this.docs.set(doc.id, doc);
	}

	async deleteDocument(id: string): Promise<void> {
		this.docs.delete(id);
	}

	async deleteDocuments(ids: Array<string>): Promise<void> {
		for (const id of ids) {
			this.docs.delete(id);
		}
	}

	async deleteByTerm(field: string, value: string): Promise<void> {
		for (const [id, doc] of this.docs) {
			if ((doc as unknown as Record<string, unknown>)[field] === value) this.docs.delete(id);
		}
	}

	async deleteAllDocuments(): Promise<void> {
		this.docs.clear();
	}

	async bulkIndexDocuments(docs: Array<TDocument>): Promise<void> {
		await this.indexDocuments(docs);
	}

	async refreshIndex(): Promise<void> {}

	async search(query: string, filters: TFilters, options?: SearchOptions): Promise<SearchResult<TDocument>> {
		const hits = Array.from(this.docs.values())
			.filter((doc) => this.matchesFilters(doc, filters))
			.filter((doc) => {
				const trimmed = query.trim();
				return (
					trimmed.length === 0 || stringArrayContainsText(this.collectText(doc, filters).filter(isString), trimmed)
				);
			})
			.sort((left, right) => this.sortDocuments(left, right, filters, query));
		const facets = options?.facets;
		return {
			hits: paginate(hits, options),
			total: hits.length,
			...(facets && facets.length > 0 ? {facetCounts: countFacets(hits, facets)} : {}),
		};
	}
}

function countFacets<TDocument>(docs: Array<TDocument>, facets: Array<string>): Record<string, Record<string, number>> {
	const counts: Record<string, Record<string, number>> = {};
	for (const facet of facets) {
		const facetCounts: Record<string, number> = {};
		for (const doc of docs) {
			const value = (doc as Record<string, unknown>)[facet];
			if (value == null) {
				continue;
			}
			for (const entry of Array.isArray(value) ? value : [value]) {
				const key = String(entry);
				facetCounts[key] = (facetCounts[key] ?? 0) + 1;
			}
		}
		counts[facet] = facetCounts;
	}
	return counts;
}

function isString(value: string | null): value is string {
	return value !== null;
}

function matchesHasFilter(doc: SearchableMessage, has: string): boolean {
	switch (has) {
		case 'link':
			return doc.hasLink;
		case 'embed':
			return doc.hasEmbed;
		case 'poll':
			return doc.hasPoll;
		case 'file':
			return doc.hasFile;
		case 'video':
			return doc.hasVideo;
		case 'image':
			return doc.hasImage;
		case 'sound':
			return doc.hasSound;
		case 'sticker':
			return doc.hasSticker;
		case 'snapshot':
			return doc.hasForward;
		default:
			return false;
	}
}

function matchesMessageFilters(doc: SearchableMessage, filters: MessageSearchFilters): boolean {
	if (filters.maxId && BigInt(doc.id) >= BigInt(filters.maxId)) return false;
	if (filters.minId && BigInt(doc.id) <= BigInt(filters.minId)) return false;
	if (filters.guildId !== undefined && doc.guildId !== filters.guildId) return false;
	if (filters.channelId !== undefined && doc.channelId !== filters.channelId) return false;
	if (filters.channelIds && !filters.channelIds.includes(doc.channelId)) return false;
	if (filters.excludeChannelIds?.includes(doc.channelId)) return false;
	if (filters.authorId && (!doc.authorId || !filters.authorId.includes(doc.authorId))) return false;
	if (filters.excludeAuthorIds?.includes(doc.authorId ?? '')) return false;
	if (filters.authorType && !filters.authorType.includes(doc.authorType)) return false;
	if (filters.excludeAuthorType?.includes(doc.authorType)) return false;
	if (filters.mentions && !filters.mentions.every((id) => doc.mentionedUserIds.includes(id))) return false;
	if (filters.excludeMentions?.some((id) => doc.mentionedUserIds.includes(id))) return false;
	if (filters.mentionEveryone !== undefined && doc.mentionEveryone !== filters.mentionEveryone) return false;
	if (filters.pinned !== undefined && doc.isPinned !== filters.pinned) return false;
	if (filters.has && !filters.has.every((entry) => matchesHasFilter(doc, entry))) return false;
	if (filters.excludeHas?.some((entry) => matchesHasFilter(doc, entry))) return false;
	if (!arrayIncludesAny(doc.embedTypes, filters.embedType)) return false;
	if (!arrayExcludesAll(doc.embedTypes, filters.excludeEmbedTypes)) return false;
	if (!arrayIncludesAny(doc.embedProviders, filters.embedProvider)) return false;
	if (!arrayExcludesAll(doc.embedProviders, filters.excludeEmbedProviders)) return false;
	if (!arrayIncludesAny(doc.linkHostnames, filters.linkHostname)) return false;
	if (!arrayExcludesAll(doc.linkHostnames, filters.excludeLinkHostnames)) return false;
	if (!arrayIncludesAny(doc.attachmentFilenames, filters.attachmentFilename)) return false;
	if (!arrayExcludesAll(doc.attachmentFilenames, filters.excludeAttachmentFilenames)) return false;
	if (!arrayIncludesAny(doc.attachmentExtensions, filters.attachmentExtension)) return false;
	if (!arrayExcludesAll(doc.attachmentExtensions, filters.excludeAttachmentExtensions)) return false;
	if (filters.content && !messageContains(doc, filters.content)) return false;
	if (filters.contents && !filters.contents.some((content) => messageContains(doc, content))) return false;
	if (filters.exactPhrases && !filters.exactPhrases.every((phrase) => (doc.content ?? '').includes(phrase)))
		return false;
	return true;
}

function messageContains(doc: SearchableMessage, query: string): boolean {
	return containsText(doc.content, query) || stringArrayContainsText(doc.embedContent, query);
}

function collectMessageText(doc: SearchableMessage): Array<string | null> {
	return [doc.content, ...doc.embedContent, ...doc.attachmentFilenames, ...doc.linkHostnames];
}

function sortMessageDocs(
	left: SearchableMessage,
	right: SearchableMessage,
	filters: MessageSearchFilters,
	query: string,
): number {
	if (filters.sortBy === 'timestamp') {
		const direction = filters.sortOrder === 'asc' ? 1 : -1;
		return (left.createdAt - right.createdAt || Number(BigInt(left.id) - BigInt(right.id))) * direction;
	}
	const scoreDelta = relevanceScore(collectMessageText(right), query) - relevanceScore(collectMessageText(left), query);
	if (scoreDelta !== 0) {
		return scoreDelta;
	}
	return Number(BigInt(right.id) - BigInt(left.id));
}

function matchesUserFilters(doc: SearchableUser, filters: UserSearchFilters): boolean {
	if (filters.isBot !== undefined && doc.isBot !== filters.isBot) return false;
	if (filters.isSystem !== undefined && doc.isSystem !== filters.isSystem) return false;
	if (filters.emailVerified !== undefined && doc.emailVerified !== filters.emailVerified) return false;
	if (filters.emailBounced !== undefined && doc.emailBounced !== filters.emailBounced) return false;
	if (filters.hasPremium !== undefined && (doc.premiumType !== null) !== filters.hasPremium) return false;
	if (filters.isTempBanned !== undefined && (doc.tempBannedUntil !== null) !== filters.isTempBanned) return false;
	if (filters.isPendingDeletion !== undefined && (doc.pendingDeletionAt !== null) !== filters.isPendingDeletion) {
		return false;
	}
	if (filters.hasAcl && !filters.hasAcl.every((acl) => doc.acls.includes(acl))) return false;
	if (filters.createdAtGreaterThanOrEqual !== undefined && doc.createdAt < filters.createdAtGreaterThanOrEqual) {
		return false;
	}
	if (filters.createdAtLessThanOrEqual !== undefined && doc.createdAt > filters.createdAtLessThanOrEqual) {
		return false;
	}
	return true;
}

function collectUserText(doc: SearchableUser, filters: UserSearchFilters): Array<string | null> {
	return [
		doc.id,
		doc.username,
		filters.excludeEmail ? null : doc.email,
		doc.stripeCustomerId,
		doc.stripeSubscriptionId,
	];
}

function sortNumericField<TDocument extends SearchableDocument, TFilters>(
	field: keyof TDocument,
	defaultOrder: 'asc' | 'desc',
): Sorter<TDocument, TFilters> {
	return (left, right, filters, query) => {
		const sortFilters = filters as {sortBy?: string; sortOrder?: 'asc' | 'desc'};
		if (sortFilters.sortBy === 'relevance') {
			const delta = relevanceScore(collectObjectText(right), query) - relevanceScore(collectObjectText(left), query);
			if (delta !== 0) return delta;
		}
		const order = sortFilters.sortOrder ?? defaultOrder;
		const direction = order === 'asc' ? 1 : -1;
		const leftValue = Number(left[field] ?? 0);
		const rightValue = Number(right[field] ?? 0);
		return (leftValue - rightValue) * direction;
	};
}

function collectObjectText(doc: SearchableDocument): Array<string | null> {
	return Object.values(doc)
		.flatMap((value) => (Array.isArray(value) ? value : [value]))
		.filter((value): value is string => typeof value === 'string');
}

function matchesGuildFilters(doc: SearchableGuild, filters: GuildSearchFilters): boolean {
	if (filters.ownerId !== undefined && doc.ownerId !== filters.ownerId) return false;
	if (filters.verificationLevel !== undefined && doc.verificationLevel !== filters.verificationLevel) return false;
	if (filters.mfaLevel !== undefined && doc.mfaLevel !== filters.mfaLevel) return false;
	if (filters.nsfwLevel !== undefined && doc.nsfwLevel !== filters.nsfwLevel) return false;
	if (filters.hasFeature && !filters.hasFeature.every((feature) => doc.features.includes(feature))) return false;
	if (filters.isDiscoverable !== undefined && doc.isDiscoverable !== filters.isDiscoverable) return false;
	if (filters.discoveryCategory !== undefined && doc.discoveryCategory !== filters.discoveryCategory) return false;
	if (
		filters.discoveryPrimaryLanguage !== undefined &&
		doc.discoveryPrimaryLanguage !== filters.discoveryPrimaryLanguage
	) {
		return false;
	}
	if (filters.discoveryTag !== undefined && !doc.discoveryTags.includes(filters.discoveryTag)) return false;
	return true;
}

function collectGuildText(doc: SearchableGuild): Array<string | null> {
	return [doc.name, doc.vanityUrlCode, doc.discoveryDescription, ...doc.discoveryTags];
}

const sortGuildsByCreatedAt = sortNumericField<SearchableGuild, GuildSearchFilters>('createdAt', 'asc');
const sortGuildsByMemberCount = sortNumericField<SearchableGuild, GuildSearchFilters>('memberCount', 'desc');

function sortGuilds(left: SearchableGuild, right: SearchableGuild, filters: GuildSearchFilters, query: string): number {
	const sorter = filters.sortBy === 'memberCount' ? sortGuildsByMemberCount : sortGuildsByCreatedAt;
	const delta = sorter(left, right, filters, query);
	if (delta !== 0) return delta;
	const leftId = BigInt(left.id);
	const rightId = BigInt(right.id);
	if (leftId === rightId) return 0;
	return leftId > rightId ? -1 : 1;
}

function matchesReportFilters(doc: SearchableReport, filters: ReportSearchFilters): boolean {
	if (filters.reporterId !== undefined && doc.reporterId !== filters.reporterId) return false;
	if (filters.status !== undefined && doc.status !== filters.status) return false;
	if (filters.reportType !== undefined && doc.reportType !== filters.reportType) return false;
	if (filters.category !== undefined && doc.category !== filters.category) return false;
	if (filters.reason !== undefined && doc.reason !== filters.reason) return false;
	if (filters.reportedUserId !== undefined && doc.reportedUserId !== filters.reportedUserId) return false;
	if (filters.reportedWebhookId !== undefined && doc.reportedWebhookId !== filters.reportedWebhookId) return false;
	if (filters.reportedGuildId !== undefined && doc.reportedGuildId !== filters.reportedGuildId) return false;
	if (filters.reportedMessageId !== undefined && doc.reportedMessageId !== filters.reportedMessageId) return false;
	if (filters.reportedChannelId !== undefined && doc.reportedChannelId !== filters.reportedChannelId) return false;
	if (filters.guildContextId !== undefined && doc.guildContextId !== filters.guildContextId) return false;
	if (filters.resolvedByAdminId !== undefined && doc.resolvedByAdminId !== filters.resolvedByAdminId) return false;
	if (filters.isResolved !== undefined && (doc.resolvedAt !== null) !== filters.isResolved) return false;
	return true;
}

function collectReportText(doc: SearchableReport): Array<string | null> {
	return [
		doc.id,
		doc.category,
		doc.additionalInfo,
		doc.reportedGuildName,
		doc.reportedChannelName,
		doc.publicComment,
		doc.reportedUserId,
		doc.reportedWebhookId,
		doc.reportedGuildId,
		doc.reportedMessageId,
	];
}

function matchesAuditLogFilters(doc: SearchableAuditLog, filters: AuditLogSearchFilters): boolean {
	if (filters.adminUserId !== undefined && doc.adminUserId !== filters.adminUserId) return false;
	if (filters.targetType !== undefined && doc.targetType !== filters.targetType) return false;
	if (filters.targetId !== undefined && doc.targetId !== filters.targetId) return false;
	if (filters.action !== undefined && doc.action !== filters.action) return false;
	if (filters.actions !== undefined && !filters.actions.includes(doc.action)) return false;
	if (filters.excludeActions?.includes(doc.action)) return false;
	return true;
}

function collectAuditLogText(doc: SearchableAuditLog): Array<string | null> {
	return [doc.id, doc.adminUserId, doc.targetType, doc.targetId, doc.action, doc.auditLogReason];
}

function matchesGuildMemberFilters(doc: SearchableGuildMember, filters: GuildMemberSearchFilters): boolean {
	if (doc.guildId !== filters.guildId) return false;
	if (filters.roleIds && !filters.roleIds.every((roleId) => doc.roleIds.includes(roleId))) return false;
	if (filters.joinedAtGte !== undefined && doc.joinedAt < filters.joinedAtGte) return false;
	if (filters.joinedAtLte !== undefined && doc.joinedAt > filters.joinedAtLte) return false;
	if (filters.joinSourceType && !filters.joinSourceType.includes(doc.joinSourceType!)) return false;
	if (filters.sourceInviteCode && !filters.sourceInviteCode.includes(doc.sourceInviteCode ?? '')) return false;
	if (filters.userCreatedAtGte !== undefined && doc.userCreatedAt < filters.userCreatedAtGte) return false;
	if (filters.userCreatedAtLte !== undefined && doc.userCreatedAt > filters.userCreatedAtLte) return false;
	if (filters.isBot !== undefined && doc.isBot !== filters.isBot) return false;
	const memberQuery = filters.query;
	if (memberQuery && !collectGuildMemberText(doc).some((value) => containsText(value, memberQuery))) return false;
	return true;
}

function collectGuildMemberText(doc: SearchableGuildMember): Array<string | null> {
	return [doc.id, doc.userId, doc.username, doc.usernameSearch, doc.discriminator, doc.globalName, doc.nickname];
}

function sortGuildMemberDocs(
	left: SearchableGuildMember,
	right: SearchableGuildMember,
	filters: GuildMemberSearchFilters,
	query: string,
): number {
	if (filters.sortBy === 'relevance') {
		const delta =
			relevanceScore(collectGuildMemberText(right), query) - relevanceScore(collectGuildMemberText(left), query);
		if (delta !== 0) return delta;
	}
	const direction = filters.sortOrder === 'asc' ? 1 : -1;
	return (left.joinedAt - right.joinedAt) * direction;
}

function compareThreadCursor(doc: SearchableThread, cursor: ThreadSearchCursor): number {
	return doc.createdAt - cursor.createdAt || doc.idSequence - cursor.idSequence;
}

function matchesThreadFilters(doc: SearchableThread, filters: ThreadSearchFilters): boolean {
	if (doc.guildId !== filters.guildId || doc.parentId !== filters.parentId) return false;
	if (filters.publicOnly && doc.type === 12 && !filters.privateThreadIds?.includes(doc.id)) return false;
	if (filters.archived !== undefined && doc.archived !== filters.archived) return false;
	if (filters.tagIds && filters.tagIds.length > 0) {
		const matches =
			filters.tagSetting === 'match_all'
				? filters.tagIds.every((id) => doc.appliedTagIds.includes(id))
				: filters.tagIds.some((id) => doc.appliedTagIds.includes(id));
		if (!matches) return false;
	}
	if (filters.after && compareThreadCursor(doc, filters.after) <= 0) return false;
	if (filters.before && compareThreadCursor(doc, filters.before) >= 0) return false;
	return true;
}

const THREAD_SORT_FIELDS = {
	last_message_time: 'lastMessageAt',
	archive_time: 'archivedAt',
	creation_time: 'createdAt',
} as const;

function sortThreadDocs(
	left: SearchableThread,
	right: SearchableThread,
	filters: ThreadSearchFilters,
	query: string,
): number {
	const sortBy = filters.sortBy ?? 'last_message_time';
	if (sortBy === 'relevance') {
		const delta = relevanceScore([right.name], query) - relevanceScore([left.name], query);
		if (delta !== 0) return delta;
		return Number(BigInt(right.id) - BigInt(left.id));
	}
	const field = THREAD_SORT_FIELDS[sortBy];
	const direction = filters.sortOrder === 'asc' ? 1 : -1;
	return (left[field] - right[field] || Number(BigInt(left.id) - BigInt(right.id))) * direction;
}

export class InMemorySearchProvider implements ISearchProvider {
	private readonly messages = new MessageSearchService(
		new InMemorySearchAdapter<MessageSearchFilters, SearchableMessage>(
			matchesMessageFilters,
			collectMessageText,
			sortMessageDocs,
		),
	);
	private readonly guilds = new GuildSearchService(
		new InMemorySearchAdapter<GuildSearchFilters, SearchableGuild>(matchesGuildFilters, collectGuildText, sortGuilds),
		new GuildDiscoveryRepository(),
	);
	private readonly users = new UserSearchService(
		new InMemorySearchAdapter<UserSearchFilters, SearchableUser>(
			matchesUserFilters,
			collectUserText,
			sortNumericField<SearchableUser, UserSearchFilters>('createdAt', 'asc'),
		),
	);
	private readonly reports = new ReportSearchService(
		new InMemorySearchAdapter<ReportSearchFilters, SearchableReport>(
			matchesReportFilters,
			collectReportText,
			sortNumericField<SearchableReport, ReportSearchFilters>('createdAt', 'desc'),
		),
	);
	private readonly auditLogs = new AuditLogSearchService(
		new InMemorySearchAdapter<AuditLogSearchFilters, SearchableAuditLog>(
			matchesAuditLogFilters,
			collectAuditLogText,
			sortNumericField<SearchableAuditLog, AuditLogSearchFilters>('createdAt', 'desc'),
		),
	);
	private readonly guildMembers = new GuildMemberSearchService(
		new InMemorySearchAdapter<GuildMemberSearchFilters, SearchableGuildMember>(
			matchesGuildMemberFilters,
			collectGuildMemberText,
			sortGuildMemberDocs,
		),
	);
	private readonly threads = new ThreadSearchIndex(
		new InMemorySearchAdapter<ThreadSearchFilters, SearchableThread>(
			matchesThreadFilters,
			(doc) => [doc.name],
			sortThreadDocs,
		),
	);

	async initialize(): Promise<void> {
		await Promise.all([
			this.messages.initialize(),
			this.guilds.initialize(),
			this.users.initialize(),
			this.reports.initialize(),
			this.auditLogs.initialize(),
			this.guildMembers.initialize(),
		]);
	}

	async shutdown(): Promise<void> {
		await Promise.all([
			this.messages.shutdown(),
			this.guilds.shutdown(),
			this.users.shutdown(),
			this.reports.shutdown(),
			this.auditLogs.shutdown(),
			this.guildMembers.shutdown(),
			this.threads.shutdown(),
		]);
	}

	getMessageSearchService(): IMessageSearchService {
		return this.messages;
	}

	getGuildSearchService(): IGuildSearchService {
		return this.guilds;
	}

	getUserSearchService(): IUserSearchService {
		return this.users;
	}

	getReportSearchService(): IReportSearchService {
		return this.reports;
	}

	getAuditLogSearchService(): IAuditLogSearchService {
		return this.auditLogs;
	}

	getGuildMemberSearchService(): IGuildMemberSearchService {
		return this.guildMembers;
	}

	getThreadSearchService(): IThreadSearchService {
		return this.threads;
	}
}