Skip to content

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

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

import {Config} from '@app/api/Config';
import {SearchProvider} from '@app/api/infrastructure/SearchProvider';
import {Logger} from '@app/api/Logger';
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 {type MeilisearchClientConfig, MeilisearchHttpClient} from '@app/api/search/meilisearch/MeilisearchClient';
import {
	MeilisearchAuditLogAdapter,
	MeilisearchGuildAdapter,
	MeilisearchGuildMemberAdapter,
	MeilisearchMessageAdapter,
	MeilisearchReportAdapter,
	MeilisearchThreadAdapter,
	MeilisearchUserAdapter,
} from '@app/api/search/meilisearch/MeilisearchDomainAdapters';
import {
	AuditLogSearchService,
	GuildMemberSearchService,
	GuildSearchService,
	MessageSearchService,
	ReportSearchService,
	UserSearchService,
} from '@app/api/search/SearchServices';
import {ThreadSearchIndex} from '@app/api/search/thread/ThreadSearchIndex';
import {DEFAULT_SEARCH_CLIENT_TIMEOUT_MS} from '@fluxer/constants/src/Timeouts';
import type {ElasticsearchDistributedLock} from '@pkgs/elasticsearch_search/src/adapters/ElasticsearchIndexAdapter';
import type {ElasticsearchClientConfig} from '@pkgs/elasticsearch_search/src/ElasticsearchClient';

let searchProvider: ISearchProvider | null = null;
let injectedSearchProvider: ISearchProvider | undefined;

function createElasticsearchSearchProvider(lock?: ElasticsearchDistributedLock): ISearchProvider {
	if (!Config.search.apiKey && !Config.search.username) {
		Logger.warn('Elasticsearch credentials are not configured; search will be unavailable');
		return new SearchProvider(null);
	}
	Logger.info({url: Config.search.url}, 'Using Elasticsearch for search');
	const config: ElasticsearchClientConfig = {
		node: Config.search.url,
		auth: Config.search.apiKey
			? {apiKey: Config.search.apiKey}
			: {username: Config.search.username, password: Config.search.password},
		requestTimeoutMs: DEFAULT_SEARCH_CLIENT_TIMEOUT_MS,
		tlsRejectUnauthorized: Config.search.tlsRejectUnauthorized,
	};
	return new SearchProvider(
		async () => {
			const {createElasticsearchSearchServices} = await import(
				'@app/api/search/elasticsearch/ElasticsearchSearchServices'
			);
			return createElasticsearchSearchServices(config, lock);
		},
		() => Logger.info({node: config.node}, 'ElasticsearchSearchProvider initialised'),
	);
}

function createMeilisearchSearchProvider(): ISearchProvider {
	Logger.info({url: Config.search.url}, 'Using Meilisearch for search');
	const config: MeilisearchClientConfig = {
		host: Config.search.url,
		apiKey: Config.search.apiKey || undefined,
		requestTimeoutMs: DEFAULT_SEARCH_CLIENT_TIMEOUT_MS,
	};
	return new SearchProvider(
		async () => {
			const {GuildDiscoveryRepository} = await import('@app/api/guild/repositories/GuildDiscoveryRepository');
			const client = new MeilisearchHttpClient(config);
			const message = new MessageSearchService(new MeilisearchMessageAdapter({client}));
			const guild = new GuildSearchService(new MeilisearchGuildAdapter({client}), new GuildDiscoveryRepository());
			const user = new UserSearchService(new MeilisearchUserAdapter({client}));
			const report = new ReportSearchService(new MeilisearchReportAdapter({client}));
			const auditLog = new AuditLogSearchService(new MeilisearchAuditLogAdapter({client}));
			const guildMember = new GuildMemberSearchService(new MeilisearchGuildMemberAdapter({client}));
			const thread = new ThreadSearchIndex(new MeilisearchThreadAdapter({client}));
			return {message, guild, user, report, auditLog, guildMember, thread};
		},
		() => Logger.info({host: config.host}, 'MeilisearchSearchProvider initialised'),
	);
}

function createSearchProvider(lock?: ElasticsearchDistributedLock): ISearchProvider {
	if (Config.search.engine === 'none') {
		Logger.info('Search is turned off');
		return new SearchProvider(null);
	}
	if (Config.search.engine === 'meilisearch') {
		return createMeilisearchSearchProvider();
	}
	return createElasticsearchSearchProvider(lock);
}

export function setInjectedSearchProvider(provider: ISearchProvider | undefined): void {
	injectedSearchProvider = provider;
	searchProvider = provider ?? null;
}

export function getMessageSearchService(): IMessageSearchService | null {
	return searchProvider?.getMessageSearchService() ?? null;
}

export function getGuildSearchService(): IGuildSearchService | null {
	return searchProvider?.getGuildSearchService() ?? null;
}

export function getUserSearchService(): IUserSearchService | null {
	return searchProvider?.getUserSearchService() ?? null;
}

export function getReportSearchService(): IReportSearchService | null {
	return searchProvider?.getReportSearchService() ?? null;
}

export function getAuditLogSearchService(): IAuditLogSearchService | null {
	return searchProvider?.getAuditLogSearchService() ?? null;
}

export function getGuildMemberSearchService(): IGuildMemberSearchService | null {
	return searchProvider?.getGuildMemberSearchService() ?? null;
}

export function getThreadSearchService(): IThreadSearchService | null {
	return searchProvider?.getThreadSearchService() ?? null;
}

export async function initializeSearch(lock?: ElasticsearchDistributedLock): Promise<void> {
	if (searchProvider) {
		await shutdownSearch();
	}
	const injectedProvider = injectedSearchProvider;
	if (injectedProvider) {
		searchProvider = injectedProvider;
		Logger.info('Using injected search provider (in-process mode)');
		await searchProvider.initialize();
		return;
	}
	const provider = createSearchProvider(lock);
	try {
		await provider.initialize();
	} catch (error) {
		Logger.error({error}, 'Search backend initialisation failed');
		try {
			await provider.shutdown();
		} catch (shutdownError) {
			Logger.warn({error: shutdownError}, 'Failed to shut down search provider after initialisation failure');
		}
		throw error;
	}
	searchProvider = provider;
	Logger.info('Search backend initialized successfully');
}

export async function shutdownSearch(): Promise<void> {
	if (searchProvider) {
		await searchProvider.shutdown();
		searchProvider = null;
	}
}