Skip to content

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

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

import {activityPubKeyId} from '@app/api/activity_pub/ActivityPub';
import {AdminRepository} from '@app/api/admin/AdminRepository';
import {AdminApiKeyRepository} from '@app/api/admin/repositories/AdminApiKeyRepository';
import {AdminArchiveRepository} from '@app/api/admin/repositories/AdminArchiveRepository';
import {AdminApiKeyService} from '@app/api/admin/services/AdminApiKeyService';
import {AdminArchiveService} from '@app/api/admin/services/AdminArchiveService';
import {Config} from '@app/api/Config';
import {ChannelRepository} from '@app/api/channel/ChannelRepository';
import {AttachmentUploadTraceRepository} from '@app/api/channel/repositories/message/AttachmentUploadTraceRepository';
import {StreamPreviewService} from '@app/api/channel/services/StreamPreviewService';
import type {APIConfig} from '@app/api/config/APIConfig';
import {ConnectionRepository} from '@app/api/connection/ConnectionRepository';
import {DonationRepository} from '@app/api/donation/DonationRepository';
import {createEmailProvider} from '@app/api/email/EmailProviderFactory';
import {EnforcementDecisionRepository} from '@app/api/enforcement/EnforcementDecisionRepository';
import {FavoriteMemeRepository} from '@app/api/favorite_meme/FavoriteMemeRepository';
import {GatewayRequestService} from '@app/api/gateway/GatewayRequestService';
import {createNatsGifProvider} from '@app/api/gif/NatsGifProvider';
import {GuildAuditLogService} from '@app/api/guild/GuildAuditLogService';
import {GuildDiscoveryRepository} from '@app/api/guild/repositories/GuildDiscoveryRepository';
import {GuildRepository} from '@app/api/guild/repositories/GuildRepository';
import {GuildDiscoveryService} from '@app/api/guild/services/GuildDiscoveryService';
import {AssetDeletionQueue} from '@app/api/infrastructure/AssetDeletionQueue';
import {AvatarService} from '@app/api/infrastructure/AvatarService';
import {CachePurgeQueue, type IPurgeQueue, NoopPurgeQueue} from '@app/api/infrastructure/CachePurgeQueue';
import {DisabledVirusScanService} from '@app/api/infrastructure/DisabledVirusScanService';
import {DiscriminatorService} from '@app/api/infrastructure/DiscriminatorService';
import {EmailDnsValidationService} from '@app/api/infrastructure/EmailDnsValidationService';
import {EmbedService} from '@app/api/infrastructure/EmbedService';
import {EntityAssetService} from '@app/api/infrastructure/EntityAssetService';
import {ErrorI18nService} from '@app/api/infrastructure/ErrorI18nService';
import type {IAssetDeletionQueue} from '@app/api/infrastructure/IAssetDeletionQueue';
import type {IStorageService} from '@app/api/infrastructure/IStorageService';
import type {IUnfurlerService} from '@app/api/infrastructure/IUnfurlerService';
import {KVAccountDeletionQueueService} from '@app/api/infrastructure/KVAccountDeletionQueueService';
import {KVActivityTracker} from '@app/api/infrastructure/KVActivityTracker';
import {KVBulkMessageDeletionQueueService} from '@app/api/infrastructure/KVBulkMessageDeletionQueueService';
import {KVThreadAutoArchiveQueueService} from '@app/api/infrastructure/KVThreadAutoArchiveQueueService';
import {NatsUnfurlerService} from '@app/api/infrastructure/NatsUnfurlerService';
import {PremiumStateReconciliationQueueService} from '@app/api/infrastructure/PremiumStateReconciliationQueueService';
import {createStorageService} from '@app/api/infrastructure/StorageServiceFactory';
import {UserCacheService} from '@app/api/infrastructure/UserCacheService';
import {createUsersServiceClient} from '@app/api/infrastructure/UsersServiceClient';
import {VirusScanService} from '@app/api/infrastructure/VirusScanService';
import {type ContactEmails, resolveContactEmails, resolveLegalAddress} from '@app/api/instance/ContactEmails';
import {CustomBadgeCatalog} from '@app/api/instance/custom_badges/CustomBadgeCatalog';
import {InstanceConfigRepository} from '@app/api/instance/InstanceConfigRepository';
import {NatsConfigPublisher} from '@app/api/instance/NatsConfigPublisher';
import {getInstanceProductName} from '@app/api/instance/ProductName';
import {ensureSetupToken} from '@app/api/instance/SetupToken';
import {InviteRepository} from '@app/api/invite/InviteRepository';
import {Logger} from '@app/api/Logger';
import {LimitConfigService} from '@app/api/limits/LimitConfigService';
import {
	acquireSnowflakeService,
	getGatewayService,
	getKVClient,
	getMediaService,
	getSnowflakeService,
	getWorkerService,
	releaseSnowflakeService,
	type SnowflakeServiceHandle,
} from '@app/api/middleware/ServiceRegistry';
import {clearSingletonsForTesting, keyedSingleton, singleton} from '@app/api/middleware/Singleton';
import {BotAuthService} from '@app/api/oauth/BotAuthService';
import {BotMfaMirrorService} from '@app/api/oauth/BotMfaMirrorService';
import {ApplicationRepository} from '@app/api/oauth/repositories/ApplicationRepository';
import {OAuth2TokenRepository} from '@app/api/oauth/repositories/OAuth2TokenRepository';
import {OperatorPassEntitlementService} from '@app/api/operator_pass/OperatorPassEntitlementService';
import {OperatorPassRepository} from '@app/api/operator_pass/OperatorPassRepository';
import {OperatorPassWallAvatarStore} from '@app/api/operator_pass/OperatorPassWallAvatarStore';
import {
	type IOperatorPassWallPublisher,
	NatsOperatorPassWallPublisher,
} from '@app/api/operator_pass/OperatorPassWallPublisher';
import {OperatorPassWallService} from '@app/api/operator_pass/OperatorPassWallService';
import {PaymentDisputeRepository} from '@app/api/payment_disputes/PaymentDisputeRepository';
import {ReadStateRepository} from '@app/api/read_state/ReadStateRepository';
import {ReadStateRequestService} from '@app/api/read_state/ReadStateRequestService';
import {ReadStateService} from '@app/api/read_state/ReadStateService';
import {ReportRepository} from '@app/api/report/ReportRepository';
import {getGuildSearchService} from '@app/api/SearchFactory';
import {AppStoreServerApiClient} from '@app/api/store_billing/app_store/AppStoreServerApiClient';
import {GooglePlayAccessTokenProvider} from '@app/api/store_billing/google_play/GooglePlayAccessTokenProvider';
import {GooglePlayDeveloperApiClient} from '@app/api/store_billing/google_play/GooglePlayDeveloperApiClient';
import {GooglePlayPushVerifier} from '@app/api/store_billing/google_play/GooglePlayPushVerifier';
import {StoreBillingRepository} from '@app/api/store_billing/StoreBillingRepository';
import {ThemeService} from '@app/api/theme/ThemeService';
import {EntranceSoundPlayService} from '@app/api/user/entrance_sound/EntranceSoundPlayService';
import {EntranceSoundRepository} from '@app/api/user/entrance_sound/EntranceSoundRepository';
import {EntranceSoundService} from '@app/api/user/entrance_sound/EntranceSoundService';
import {EmailChangeRepository} from '@app/api/user/repositories/auth/EmailChangeRepository';
import {PasswordChangeRepository} from '@app/api/user/repositories/auth/PasswordChangeRepository';
import {UserContactChangeLogRepository} from '@app/api/user/repositories/UserContactChangeLogRepository';
import {UserRepository} from '@app/api/user/repositories/UserRepository';
import {VisionarySlotRepository} from '@app/api/user/repositories/VisionarySlotRepository';
import {UserActivityBuffer} from '@app/api/user/services/UserActivityBuffer';
import {UserContactChangeLogService} from '@app/api/user/services/UserContactChangeLogService';
import {awaitAll} from '@app/api/utils/ConcurrencyUtils';
import {StoredSecretVerifier} from '@app/api/utils/StoredSecret';
import {UserPermissionUtils} from '@app/api/utils/UserPermissionUtils';
import {VoiceP2pConnectionReportRepository} from '@app/api/voice/VoiceP2pConnectionReportRepository';
import {VoiceRepository} from '@app/api/voice/VoiceRepository';
import {SweegoWebhookService} from '@app/api/webhook/SweegoWebhookService';
import {WebhookRepository} from '@app/api/webhook/WebhookRepository';
import type {ICacheService} from '@pkgs/cache/src/ICacheService';
import {KVCacheProvider} from '@pkgs/cache/src/providers/KVCacheProvider';
import type {EmailConfig, UserBouncedEmailChecker} from '@pkgs/email/src/EmailProviderTypes';
import {EmailService} from '@pkgs/email/src/EmailService';
import type {IEmailService} from '@pkgs/email/src/IEmailService';
import {TestEmailService} from '@pkgs/email/src/TestEmailService';
import {NatsConnectionManager} from '@pkgs/nats/src/NatsConnectionManager';
import {RateLimitService} from '@pkgs/rate_limit/src/RateLimitService';
import type {IVirusScanService} from '@pkgs/virus_scan/src/IVirusScanService';

export const getUserRepository = singleton(() => new UserRepository(getKVClient()));
export const getGuildRepository = singleton(() => new GuildRepository());
export const getChannelRepository = singleton(() => new ChannelRepository());
export const getInviteRepository = singleton(() => new InviteRepository());
export const getWebhookRepository = singleton(() => new WebhookRepository());
export const getReadStateRepository = singleton(() => new ReadStateRepository());
export const getFavoriteMemeRepository = singleton(() => new FavoriteMemeRepository());
export const getConnectionRepository = singleton(() => new ConnectionRepository());
export const getReportRepository = singleton(() => new ReportRepository());
export const getEnforcementDecisionRepository = singleton(() => new EnforcementDecisionRepository());
export const getVoiceP2pConnectionReportRepository = singleton(() => new VoiceP2pConnectionReportRepository());
export const getAdminRepository = singleton(() => new AdminRepository());
export const getAdminArchiveRepository = singleton(() => new AdminArchiveRepository());
export const getVoiceRepository = singleton(() => new VoiceRepository());
export const getApplicationRepository = singleton(() => new ApplicationRepository());
export const getOAuth2TokenRepository = singleton(() => new OAuth2TokenRepository());
export const getGuildDiscoveryRepository = singleton(() => new GuildDiscoveryRepository());
export const getEmailChangeRepository = singleton(() => new EmailChangeRepository());
export const getPasswordChangeRepository = singleton(() => new PasswordChangeRepository());
const getUserContactChangeLogRepository = singleton(() => new UserContactChangeLogRepository());
export const getDonationRepository = singleton(() => new DonationRepository());
export const getOperatorPassRepository = singleton(() => new OperatorPassRepository());
export const getPaymentDisputeRepository = singleton(() => new PaymentDisputeRepository());
export const getStoreBillingRepository = singleton(() => new StoreBillingRepository());
export const getAppStoreServerApiClient = singleton(() => new AppStoreServerApiClient());
const getGooglePlayAccessTokenProvider = singleton(() => new GooglePlayAccessTokenProvider());
export const getGooglePlayDeveloperApiClient = singleton(
	() => new GooglePlayDeveloperApiClient({accessTokenProvider: getGooglePlayAccessTokenProvider()}),
);
export const getGooglePlayPushVerifier = singleton(() => new GooglePlayPushVerifier());
const getAdminApiKeyRepository = singleton(() => new AdminApiKeyRepository());
let instanceConfigRepositoryInstance: InstanceConfigRepository | null = null;
export const getInstanceConfigRepository = singleton(
	() => {
		const repository = new InstanceConfigRepository(getKVClient());
		instanceConfigRepositoryInstance = repository;
		return repository;
	},
	(repository) => {
		if (instanceConfigRepositoryInstance === repository) instanceConfigRepositoryInstance = null;
		void repository.shutdown().catch((error) => {
			Logger.error({error}, 'Failed to shut down instance config repository');
		});
	},
);

export async function shutdownInstanceConfigRepository(): Promise<void> {
	await instanceConfigRepositoryInstance?.shutdown();
}

export const getNatsConfigPublisher = singleton(
	() =>
		new NatsConfigPublisher(
			new NatsConnectionManager({
				url: Config.nats.coreUrl,
				token: Config.nats.authToken || undefined,
				name: 'fluxer-api-config',
			}),
		),
);

export const getVisionarySlotRepository = singleton(() => new VisionarySlotRepository());
export const getCacheService: () => ICacheService = singleton(() => new KVCacheProvider({client: getKVClient()}));
export const getStoredSecretVerifier = singleton(() => new StoredSecretVerifier(getCacheService()));
export const getCustomBadgeCatalog = singleton(
	() =>
		new CustomBadgeCatalog({
			instanceConfigRepository: getInstanceConfigRepository(),
			cacheService: getCacheService(),
			snowflakeService: getSnowflakeService(),
			mediaEndpoint: () => Config.endpoints.media,
		}),
);
export const getRateLimitService = singleton(() => new RateLimitService(getKVClient()));
export const getEmailDnsValidationService = singleton(() => new EmailDnsValidationService());
export const getOperatorPassEntitlementService = singleton(
	() => new OperatorPassEntitlementService(getOperatorPassRepository()),
);
export const getOperatorPassWallService = singleton(
	() => new OperatorPassWallService(getOperatorPassRepository(), getUserRepository(), getCacheService()),
);

interface OperatorPassWallInfrastructure {
	avatarStore: OperatorPassWallAvatarStore;
	publisher: IOperatorPassWallPublisher;
	nextId: () => Promise<bigint>;
}

export const getOperatorPassWallInfrastructure = singleton<OperatorPassWallInfrastructure>(() => ({
	avatarStore: new OperatorPassWallAvatarStore(getStorageService(), getPurgeQueue()),
	publisher:
		serviceSingletonInitializationOwner?.operatorPassWallPublisher ??
		new NatsOperatorPassWallPublisher(
			new NatsConnectionManager({
				url: Config.nats.coreUrl,
				token: Config.nats.authToken || undefined,
				name: 'fluxer-api-operator-wall',
			}),
		),
	nextId: () => getSnowflakeService().generate(),
}));

function createEmailServiceForConfig(
	emailConfigSource: APIConfig['email'],
	contactEmails: ContactEmails,
	productName: string,
	bouncedEmailChecker: UserBouncedEmailChecker,
): IEmailService {
	const emailConfig: EmailConfig = {
		enabled: emailConfigSource.enabled,
		fromEmail: emailConfigSource.fromEmail,
		fromName: emailConfigSource.fromName.trim() || productName,
		replyTo: emailConfigSource.replyToEmail || null,
		appBaseUrl: emailConfigSource.appBaseUrl,
		apiBaseUrl: Config.endpoints.apiPublic,
		appealsEmail: contactEmails.appealsEmail,
		privacyEmail: contactEmails.privacyEmail,
		safetyEmail: contactEmails.safetyEmail,
		supportEmail: contactEmails.supportEmail,
		productName,
		marketingBaseUrl: Config.endpoints.marketing,
		staticCdnBaseUrl: Config.endpoints.staticCdn,
		legalAddress: resolveLegalAddress(),
		brandLogo: !Config.instance.selfHosted,
	};
	return new EmailService(emailConfig, createEmailProvider(emailConfigSource), bouncedEmailChecker);
}

function createRuntimeEmailService(bouncedEmailChecker: UserBouncedEmailChecker): IEmailService {
	return new Proxy({} as IEmailService, {
		get(_target, property) {
			return async (...args: Array<unknown>): Promise<boolean> => {
				const instanceConfigRepository = getInstanceConfigRepository();
				const emailConfig = await instanceConfigRepository.getEffectiveEmailConfig();
				const delegate = createEmailServiceForConfig(
					emailConfig,
					resolveContactEmails(),
					getInstanceProductName(),
					bouncedEmailChecker,
				);
				const method = delegate[property as keyof IEmailService];
				if (typeof method !== 'function') {
					throw new Error(`Unknown email service method: ${String(property)}`);
				}
				return (method as (this: IEmailService, ...methodArgs: Array<unknown>) => Promise<boolean>).apply(
					delegate,
					args,
				);
			};
		},
	});
}

let _injectedStorageService: IStorageService | undefined;

export function setInjectedStorageService(service: IStorageService | undefined): void {
	_injectedStorageService = service;
}

export const getStorageService: () => IStorageService = (() => {
	const fallback = singleton(() => createStorageService());
	return () => _injectedStorageService ?? fallback();
})();
export const getErrorI18nService = singleton(() => new ErrorI18nService());
let limitConfigServiceInstance: LimitConfigService | null = null;
export const getLimitConfigService = singleton(
	() => {
		const service = new LimitConfigService(getInstanceConfigRepository(), getCacheService(), getKVClient());
		limitConfigServiceInstance = service;
		return service;
	},
	(service) => {
		const shutdown = limitConfigServiceInstance === service ? shutdownServiceSingletons() : service.shutdown();
		if (limitConfigServiceInstance === service) {
			limitConfigServiceInstance = null;
		}
		void shutdown.catch((err) => {
			Logger.error({err}, 'Failed to shut down service singletons');
		});
	},
);
export const getPurgeQueue: () => IPurgeQueue = singleton(() =>
	Config.cachePurge.adapter === 'none' ? new NoopPurgeQueue() : new CachePurgeQueue(getKVClient()),
);
export const getAssetDeletionQueue: () => IAssetDeletionQueue = singleton(() => new AssetDeletionQueue(getKVClient()));

export const getKVBulkMessageDeletionQueue = keyedSingleton(
	getKVClient,
	(kv) => new KVBulkMessageDeletionQueueService(kv, getUserRepository()),
);
export const getKVThreadAutoArchiveQueue = keyedSingleton(getKVClient, (kv) => new KVThreadAutoArchiveQueueService(kv));
export const getPremiumStateReconciliationQueueService = keyedSingleton(
	getKVClient,
	(kv) => new PremiumStateReconciliationQueueService(kv),
);
export const getKVActivityTracker = keyedSingleton(
	getKVClient,
	(kv) => new KVActivityTracker(kv),
	(tracker) => tracker.shutdown(),
);
export const getUserActivityBuffer = keyedSingleton(getKVClient, (kv) => new UserActivityBuffer(kv));
export const getKVAccountDeletionQueue = keyedSingleton(
	getKVClient,
	(kv) => new KVAccountDeletionQueueService(kv, getUserRepository()),
);

export const getThemeService = singleton(() => new ThemeService(getStorageService()));
export const getAttachmentUploadTraceRepository = singleton(() => new AttachmentUploadTraceRepository());

export const getVirusScanServiceInstance: () => IVirusScanService = singleton(() => {
	const VirusScanServiceClass = Config.clamav.enabled ? VirusScanService : DisabledVirusScanService;
	const service = new VirusScanServiceClass(getCacheService());
	return service;
});

export const getEmailService: () => IEmailService = singleton(() => {
	if (Config.dev.testModeEnabled) return new TestEmailService();
	const userRepository = getUserRepository();
	const bouncedEmailChecker: UserBouncedEmailChecker = {
		isEmailBounced: async (email: string) => {
			const user = await userRepository.findByEmail(email);
			return user?.emailBounced ?? false;
		},
	};
	return createRuntimeEmailService(bouncedEmailChecker);
});
let _injectedUnfurlerService: IUnfurlerService | undefined;

export function setInjectedUnfurlerService(service: IUnfurlerService | undefined): void {
	_injectedUnfurlerService = service;
}

const getDefaultUnfurlerService = singleton(() => {
	const instanceConfigRepository = getInstanceConfigRepository();
	const manager = new NatsConnectionManager({
		url: Config.nats.coreUrl,
		token: Config.nats.authToken || undefined,
		name: 'fluxer-api-unfurl',
	});
	void manager.connect().catch((error) => {
		Logger.error({error}, '[nats-unfurl] Failed to establish NATS connection');
	});
	return new NatsUnfurlerService(
		manager,
		async () => instanceConfigRepository.getEffectiveYoutubeApiKey(),
		async () => (await instanceConfigRepository.getEffectiveGifConfig()).klipy_api_key,
		activityPubKeyId(Config.endpoints.apiPublicDiscovery),
	);
});

export function getUnfurlerService(): IUnfurlerService {
	return _injectedUnfurlerService ?? getDefaultUnfurlerService();
}

export const getEmbedService = singleton(
	() => new EmbedService(getUnfurlerService(), getMediaService(), getWorkerService()),
);
export const getReadStateService = singleton(() => new ReadStateService(getReadStateRepository(), getGatewayService()));
export const getDiscriminatorService = singleton(
	() => new DiscriminatorService(getUserRepository(), getCacheService(), getLimitConfigService()),
);
export const getBotAuthService = singleton(
	() => new BotAuthService(getApplicationRepository(), getUserRepository(), getStoredSecretVerifier()),
);
export const getBotMfaMirrorService = singleton(
	() => new BotMfaMirrorService(getApplicationRepository(), getUserRepository(), getGatewayService()),
);
export const getGifService = singleton(() => {
	const instanceConfigRepository = getInstanceConfigRepository();
	return createNatsGifProvider(async () => (await instanceConfigRepository.getEffectiveGifConfig()).klipy_api_key);
});
export const getGuildAuditLogService = singleton(
	() => new GuildAuditLogService(getGuildRepository(), getSnowflakeService(), getWorkerService(), getGatewayService()),
);
export const getUserPermissionUtils = singleton(
	() => new UserPermissionUtils(getUserRepository(), getGuildRepository()),
);
export const getContactChangeLogService = singleton(
	() => new UserContactChangeLogService(getUserContactChangeLogRepository()),
);
export const getSweegoWebhookService = singleton(
	() => new SweegoWebhookService(getUserRepository(), getGatewayService()),
);
export const getStreamPreviewService = singleton(
	() => new StreamPreviewService(getStorageService(), getCacheService()),
);
export const getAvatarService = singleton(
	() => new AvatarService(getStorageService(), getMediaService(), getLimitConfigService()),
);
export const getEntityAssetService = singleton(
	() =>
		new EntityAssetService(getStorageService(), getMediaService(), getAssetDeletionQueue(), getLimitConfigService()),
);
export const getAdminApiKeyService = singleton(
	() => new AdminApiKeyService(getAdminApiKeyRepository(), getSnowflakeService(), getStoredSecretVerifier()),
);
export const getAdminArchiveService = singleton(
	() =>
		new AdminArchiveService(
			getAdminArchiveRepository(),
			getUserRepository(),
			getGuildRepository(),
			getStorageService(),
			getSnowflakeService(),
			getWorkerService(),
		),
);
const getEntranceSoundRepository = singleton(() => new EntranceSoundRepository());
export const getEntranceSoundService = singleton(
	() => new EntranceSoundService(getEntranceSoundRepository(), getStorageService(), getMediaService()),
);
export const getEntranceSoundPlayService = singleton(
	() => new EntranceSoundPlayService(getEntranceSoundService(), getGatewayService(), getChannelRepository()),
);
export const getGatewayRequestService = singleton(() => new GatewayRequestService(getBotAuthService()));
export const getGuildDiscoveryService = singleton(
	() =>
		new GuildDiscoveryService(
			getGuildDiscoveryRepository(),
			getGuildRepository(),
			getGatewayService(),
			getGuildSearchService(),
			getChannelRepository().channelData,
		),
);
export const getReadStateRequestService = singleton(() => new ReadStateRequestService(getReadStateService()));
export const getUserCacheService = singleton(() => createUserCacheService());

export function createUserCacheService(): UserCacheService {
	return new UserCacheService(createUsersServiceClient());
}

export interface ServiceSingletonDependencies {
	operatorPassWallPublisher?: IOperatorPassWallPublisher;
}

interface ServiceSingletonInitializationOwner extends ServiceSingletonDependencies {
	stopping: boolean;
	snowflake: SnowflakeServiceHandle;
	limitConfigService: LimitConfigService | null;
}

let serviceSingletonInitializationOwner: ServiceSingletonInitializationOwner | null = null;
let serviceSingletonInitializationPromise: Promise<void> | null = null;
let serviceSingletonShutdownPromise: Promise<void> | null = null;

function assertServiceSingletonInitializationActive(owner: ServiceSingletonInitializationOwner): void {
	if (owner.stopping) {
		throw new Error('Service singleton initialization was stopped');
	}
}

export async function initializeServiceSingletons(dependencies: ServiceSingletonDependencies = {}): Promise<void> {
	if (serviceSingletonShutdownPromise) {
		throw new Error('Service singletons are shutting down');
	}
	if (!serviceSingletonInitializationPromise) {
		const owner: ServiceSingletonInitializationOwner = {
			operatorPassWallPublisher: dependencies.operatorPassWallPublisher,
			stopping: false,
			snowflake: acquireSnowflakeService(),
			limitConfigService: null,
		};
		serviceSingletonInitializationOwner = owner;
		serviceSingletonInitializationPromise = (async () => {
			await owner.snowflake.service.initialize();
			assertServiceSingletonInitializationActive(owner);
			const limitConfigService = getLimitConfigService();
			owner.limitConfigService = limitConfigService;
			await getInstanceConfigRepository().initialize();
			assertServiceSingletonInitializationActive(owner);
			await getInstanceConfigRepository().ensureAccountIdentityMode();
			await getInstanceConfigRepository().ensureAccountsDefaults();
			assertServiceSingletonInitializationActive(owner);
			await ensureSetupToken(
				getInstanceConfigRepository(),
				async (userId) => (await getUserRepository().findUnique(userId)) !== null,
			);
			assertServiceSingletonInitializationActive(owner);
			await limitConfigService.initialize();
			assertServiceSingletonInitializationActive(owner);
			limitConfigService.setAsGlobalInstance();
		})();
	}
	const initialization = serviceSingletonInitializationPromise;
	try {
		await initialization;
	} catch (error) {
		if (serviceSingletonInitializationPromise === initialization) {
			try {
				await shutdownServiceSingletons();
			} catch (cleanupError) {
				throw new AggregateError([error, cleanupError], 'Service singleton initialization and cleanup failed');
			}
		}
		throw error;
	}
}

export async function shutdownServiceSingletons(): Promise<void> {
	if (serviceSingletonShutdownPromise) {
		return await serviceSingletonShutdownPromise;
	}
	const initialization = serviceSingletonInitializationPromise;
	const owner = serviceSingletonInitializationOwner;
	const service = owner?.limitConfigService ?? limitConfigServiceInstance;
	if (!initialization && !owner && !service) return;
	if (owner) owner.stopping = true;
	const shutdown = awaitAll(
		[
			Promise.resolve().then(() => service?.shutdown()),
			(async () => {
				await Promise.allSettled([initialization]);
				if (owner) await releaseSnowflakeService(owner.snowflake);
			})(),
		],
		'Failed to shut down service singletons',
	);
	serviceSingletonShutdownPromise = shutdown;
	try {
		await shutdown;
	} finally {
		if (serviceSingletonInitializationPromise === initialization) {
			serviceSingletonInitializationPromise = null;
		}
		if (serviceSingletonInitializationOwner === owner) {
			serviceSingletonInitializationOwner = null;
		}
		if (serviceSingletonShutdownPromise === shutdown) {
			serviceSingletonShutdownPromise = null;
		}
	}
}

export function resetServiceSingletonsForTesting(): void {
	void shutdownServiceSingletons().catch((error) => {
		Logger.error({error}, 'Failed to reset service singletons');
	});
	clearSingletonsForTesting();
}