sendou.ink/scripts/benchmark-db/cases.ts

import { eachDayOfInterval, subDays } from "date-fns";
import * as AdminRepository from "~/features/admin/AdminRepository.server";
import * as ExternalStreamRepository from "~/features/admin/ExternalStreamRepository.server";
import * as ModAuditLogRepository from "~/features/admin/ModAuditLogRepository.server";
import * as ApiRepository from "~/features/api/ApiRepository.server";
import * as ArtRepository from "~/features/art/ArtRepository.server";
import * as AssociationRepository from "~/features/associations/AssociationRepository.server";
import * as LogInLinkRepository from "~/features/auth/LogInLinkRepository.server";
import * as AvailabilityRepository from "~/features/availability/AvailabilityRepository.server";
import * as BadgeRepository from "~/features/badges/BadgeRepository.server";
import * as BroadcastRepository from "~/features/broadcast/BroadcastRepository.server";
import * as BuildRepository from "~/features/builds/BuildRepository.server";
import { RECENT_PATCHES } from "~/features/builds/builds-constants";
import * as CalendarRepository from "~/features/calendar/CalendarRepository.server";
import * as ChatRepository from "~/features/chat/ChatRepository.server";
import * as ChatRoomResolver from "~/features/chat/ChatRoomResolver.server";
import * as FeedCommentRepository from "~/features/feed/FeedCommentRepository.server";
import * as FeedEventRepository from "~/features/feed/FeedEventRepository.server";
import * as FeedReactionRepository from "~/features/feed/FeedReactionRepository.server";
import * as FeedRepository from "~/features/feed/FeedRepository.server";
import {
	FEED_EVENT_MAX_RETENTION_DAYS,
	FEED_ITEM_TYPES,
	FEED_MAX_AGE_HALF_LIVES,
	FEED_ROTATION_LOOKBACK_WEEKS,
	FEED_SCRIM_HISTORY_DAYS,
	FEED_SCRIM_LOOKING_NOW_HOURS,
} from "~/features/feed/feed-constants";
import * as FriendRepository from "~/features/friends/FriendRepository.server";
import * as ImageRepository from "~/features/img-upload/ImageRepository.server";
import * as LeaderboardRepository from "~/features/leaderboards/LeaderboardRepository.server";
import * as LFGRepository from "~/features/lfg/LFGRepository.server";
import * as LiveStreamRepository from "~/features/live-streams/LiveStreamRepository.server";
import * as LobbyMatchRepository from "~/features/lobbies/LobbyMatchRepository.server";
import * as LobbyRepository from "~/features/lobbies/LobbyRepository.server";
import * as MatchProfileRepository from "~/features/match-profile/MatchProfileRepository.server";
import * as Seasons from "~/features/mmr/core/Seasons";
import * as SkillRepository from "~/features/mmr/SkillRepository.server";
import * as NotificationRepository from "~/features/notifications/NotificationRepository.server";
import * as PlusSuggestionRepository from "~/features/plus-suggestions/PlusSuggestionRepository.server";
import * as PlusVotingRepository from "~/features/plus-voting/PlusVotingRepository.server";
import * as ScannerIngestRepository from "~/features/scanner-ingest/ScannerIngestRepository.server";
import * as ScrimMapListRepository from "~/features/scrims/ScrimMapListRepository.server";
import * as ScrimMapRepository from "~/features/scrims/ScrimMapRepository.server";
import * as ScrimPostRepository from "~/features/scrims/ScrimPostRepository.server";
import * as PrivateUserNoteRepository from "~/features/sendouq/PrivateUserNoteRepository.server";
import * as SQGroupRepository from "~/features/sendouq/SQGroupRepository.server";
import * as GroupMatchContinueVoteRepository from "~/features/sendouq-match/GroupMatchContinueVoteRepository.server";
import * as PlayerStatRepository from "~/features/sendouq-match/PlayerStatRepository.server";
import * as ReportedWeaponRepository from "~/features/sendouq-match/ReportedWeaponRepository.server";
import * as SQMatchRepository from "~/features/sendouq-match/SQMatchRepository.server";
import * as QStreamsRepository from "~/features/sendouq-streams/QStreamsRepository.server";
import * as SplatoonRotationRepository from "~/features/splatoon-rotations/SplatoonRotationRepository.server";
import * as TeamRepository from "~/features/team/TeamRepository.server";
import * as XRankPlacementRepository from "~/features/top-search/XRankPlacementRepository.server";
import * as SavedCalendarEventRepository from "~/features/tournament/SavedCalendarEventRepository.server";
import * as TournamentAuditLogRepository from "~/features/tournament/TournamentAuditLogRepository.server";
import * as TournamentRepository from "~/features/tournament/TournamentRepository.server";
import * as TournamentTeamRepository from "~/features/tournament/TournamentTeamRepository.server";
import * as BracketRepository from "~/features/tournament-bracket/BracketRepository.server";
import * as TournamentMatchVodRepository from "~/features/tournament-bracket/TournamentMatchVodRepository.server";
import * as TournamentLFGRepository from "~/features/tournament-lfg/TournamentLFGRepository.server";
import * as TournamentMatchRepository from "~/features/tournament-match/TournamentMatchRepository.server";
import * as TournamentOrganizationRepository from "~/features/tournament-organization/TournamentOrganizationRepository.server";
import { LUTI_ORGANIZATION_ID } from "~/features/tournament-organization/tournament-organization-constants";
import * as TrophyRepository from "~/features/trophies/TrophyRepository.server";
import * as UserCardRepository from "~/features/user-card/UserCardRepository.server";
import * as UserRepository from "~/features/user-page/UserRepository.server";
import * as VodRepository from "~/features/vods/VodRepository.server";
import type { MainWeaponId } from "~/modules/in-game-lists/types";
import {
	weaponCategories,
	weaponIdToCategory,
} from "~/modules/in-game-lists/weapon-ids";
import { LUTI_NAME_PREFIX } from "~/routines/computeLutiDivs";
import {
	databaseTimestampToDate,
	dateToDatabaseTimestamp,
	dateToYYYYMMDD,
} from "~/utils/dates";
import type { Fixtures } from "./fixtures";

const SEARCH_QUERY = { query: "s", limit: 25 };
const HOUR = 60 * 60;
const DAY = 24 * HOUR;
/** Look-back windows of `FeedItems.server.ts` */
const FEED_RECENT_ACTIVITY_DAYS = 30;
const FEED_SERIES_STANDINGS_DAYS = 90;
const FEED_HIGH_XP = 3000;
const FEED_SITE_TOTALS: FeedRepository.SiteTotal[] = [
	"USERS",
	"SQ_SETS",
	"TOURNAMENTS",
	"ART",
];
const LFG_NO_FILTERS = {
	type: null,
	weapons: [],
	plusTier: null,
	language: null,
	timezones: null,
	postIds: null,
};

export interface BenchmarkCase {
	name: string;
	run: () => Promise<unknown>;
}

/** Builds the benchmark case registry from resolved fixtures; cases whose fixture resolved to null go to `skipped`. */
export function buildCases(fx: Fixtures): {
	cases: BenchmarkCase[];
	skipped: string[];
} {
	const cases: BenchmarkCase[] = [];
	const skipped: string[] = [];

	function add<T>(
		name: string,
		fixture: T | null,
		run: (fixture: T) => unknown,
	) {
		if (fixture === null) {
			skipped.push(name);
			return;
		}
		cases.push({ name, run: async () => run(fixture) });
	}

	function addStatic(name: string, run: () => unknown) {
		cases.push({ name, run: async () => run() });
	}

	addStatic("AdminRepository.findAllBannedUsers", () =>
		AdminRepository.findAllBannedUsers(),
	);
	add("AdminRepository.findModNoteById", fx.modNoteId, (id) =>
		AdminRepository.findModNoteById(id),
	);

	addStatic("ExternalStreamRepository.findAll", () =>
		ExternalStreamRepository.findAll(),
	);
	addStatic("ExternalStreamRepository.findAllForSidebar", () =>
		ExternalStreamRepository.findAllForSidebar(),
	);

	add("ApiRepository.findTokenByUserId", fx.apiTokenUserId, (userId) =>
		ApiRepository.findTokenByUserId(userId, "read"),
	);
	addStatic("ApiRepository.findAllApiTokens", () =>
		ApiRepository.findAllApiTokens(),
	);

	addStatic("ArtRepository.findShowcaseArts", () =>
		ArtRepository.findShowcaseArts(),
	);
	add("ArtRepository.findShowcaseArtsByTag", fx.heavyArtTagId, (tagId) =>
		ArtRepository.findShowcaseArtsByTag(tagId),
	);
	addStatic("ArtRepository.findRecentlyUploadedArts", () =>
		ArtRepository.findRecentlyUploadedArts(),
	);
	addStatic("ArtRepository.findAllTags", () => ArtRepository.findAllTags());
	add("ArtRepository.findArtsByUserId", fx.heavyArtUserId, (userId) =>
		ArtRepository.findArtsByUserId(userId),
	);
	add("ArtRepository.findById", fx.heavyArtId, (artId) =>
		ArtRepository.findById(artId),
	);

	add("AssociationRepository.findById", fx.heavyAssociation, (association) =>
		AssociationRepository.findById(association.id, { withMembers: true }),
	);
	add(
		"AssociationRepository.findByMemberUserId",
		fx.heavyAssociation,
		(association) =>
			AssociationRepository.findByMemberUserId(association.memberUserId, {
				withMembers: true,
			}),
	);
	add(
		"AssociationRepository.findByInviteCode",
		fx.heavyAssociation,
		(association) =>
			AssociationRepository.findByInviteCode(association.inviteCode, {
				withMembers: true,
			}),
	);
	add(
		"AssociationRepository.findInviteCodeById",
		fx.heavyAssociation,
		(association) => AssociationRepository.findInviteCodeById(association.id),
	);

	add("LogInLinkRepository.findValidByCode", fx.logInLinkCode, (code) =>
		LogInLinkRepository.findValidByCode(code),
	);

	add(
		"AvailabilityRepository.findScheduleVisibleUserIds",
		both(fx.manyUserIds, fx.heavyUser),
		([userIds, user]) =>
			AvailabilityRepository.findScheduleVisibleUserIds({
				userIds,
				viewerId: user.id,
			}),
	);
	add(
		"AvailabilityRepository.findAllWeeksByUserIds",
		both(fx.manyUserIds, fx.availabilityWindow),
		([userIds, window]) =>
			AvailabilityRepository.findAllWeeksByUserIds({
				userIds,
				startsAt: window.startsAt,
				endsAt: window.endsAt,
			}),
	);
	add(
		"AvailabilityRepository.hasReportedWeek",
		both(fx.heavyUser, fx.availabilityWindow),
		([user, window]) =>
			AvailabilityRepository.hasReportedWeek({
				userId: user.id,
				weekStartsAt: window.weekStartsAt,
			}),
	);
	add(
		"AvailabilityRepository.findWeekReminderUserIds",
		fx.availabilityWindow,
		(window) =>
			AvailabilityRepository.findWeekReminderUserIds(window.weekStartsAt),
	);
	add(
		"AvailabilityRepository.findAllTeamEventsByUserIds",
		both(fx.manyUserIds, fx.availabilityWindow),
		([userIds, window]) =>
			AvailabilityRepository.findAllTeamEventsByUserIds({
				userIds,
				startsAt: window.startsAt,
				endsAt: window.endsAt,
			}),
	);
	add(
		"AvailabilityRepository.findTeamEventsByTeamId",
		both(fx.heavyTeam, fx.availabilityWindow),
		([team, window]) =>
			AvailabilityRepository.findTeamEventsByTeamId({
				teamId: team.id,
				startsAt: window.startsAt,
				endsAt: window.endsAt,
			}),
	);
	add(
		"AvailabilityRepository.findAllUpcomingTeamEventsByUserId",
		both(fx.heavyTeam, fx.availabilityWindow),
		([team, window]) =>
			AvailabilityRepository.findAllUpcomingTeamEventsByUserId({
				userId: team.memberUserId,
				startsAt: window.startsAt,
				endsAt: window.endsAt,
			}),
	);
	add("AvailabilityRepository.findTeamEventById", fx.teamEventId, (id) =>
		AvailabilityRepository.findTeamEventById(id),
	);

	addStatic("BadgeRepository.findAll", () => BadgeRepository.findAll());
	add("BadgeRepository.findById", fx.heavyBadgeId, (badgeId) =>
		BadgeRepository.findById(badgeId),
	);
	add("BadgeRepository.findByManagersList", fx.manyUserIds, (userIds) =>
		BadgeRepository.findByManagersList(userIds),
	);
	add("BadgeRepository.findManagedByUserId", fx.badgeManagerUserId, (userId) =>
		BadgeRepository.findManagedByUserId(userId),
	);
	add("BadgeRepository.findByOwnerUserId", fx.badgeOwnerUserId, (userId) =>
		BadgeRepository.findByOwnerUserId(userId, []),
	);
	add("BadgeRepository.findByAuthorUserId", fx.badgeAuthorId, (userId) =>
		BadgeRepository.findByAuthorUserId(userId),
	);

	add("BroadcastRepository.findByChannel", fx.broadcast, (broadcast) =>
		BroadcastRepository.findByChannel(broadcast),
	);
	add("BroadcastRepository.findAllByChatRoomIds", fx.broadcast, (broadcast) =>
		BroadcastRepository.findAllByChatRoomIds(broadcast.chatRoomIds),
	);
	add(
		"BroadcastRepository.findAllCastersByUserIds",
		fx.manyUserIds,
		(userIds) => BroadcastRepository.findAllCastersByUserIds(userIds),
	);
	add(
		"BroadcastRepository.findAllPlayersByTournamentTeamIds",
		fx.manyTournamentTeamIds,
		(tournamentTeamIds) =>
			BroadcastRepository.findAllPlayersByTournamentTeamIds(tournamentTeamIds),
	);
	add(
		"BroadcastRepository.findAllGameResultsByMatchIds",
		fx.manyTournamentMatchIds,
		(matchIds) => BroadcastRepository.findAllGameResultsByMatchIds(matchIds),
	);
	add(
		"BroadcastRepository.findMapPoolByTournamentTeamId",
		fx.heavyTournamentTeamId,
		(tournamentTeamId) =>
			BroadcastRepository.findMapPoolByTournamentTeamId(tournamentTeamId),
	);

	add("BuildRepository.findAllByUserId", fx.heavyBuildUserId, (userId) =>
		BuildRepository.findAllByUserId(userId, {
			showPrivate: true,
			sortAbilities: true,
		}),
	);
	add("BuildRepository.findOwnerIdById", fx.buildId, (buildId) =>
		BuildRepository.findOwnerIdById(buildId),
	);
	addStatic("BuildRepository.findAllAbilityPointSums", () =>
		BuildRepository.findAllAbilityPointSums(RECENT_PATCHES.at(-1)!.date),
	);
	add(
		"BuildRepository.findAbilityPointCountsByWeaponIds",
		fx.heavyWeaponSplId,
		(weaponSplId) =>
			BuildRepository.findAbilityPointCountsByWeaponIds({
				weaponIds: categoryWeaponIds(weaponSplId),
				updatedSince: RECENT_PATCHES.at(-1)!.date,
			}),
	);
	add(
		"BuildRepository.findNewestBuildPerOwnerByWeaponId",
		fx.heavyWeaponSplId,
		(weaponSplId) =>
			BuildRepository.findNewestBuildPerOwnerByWeaponId({
				weaponId: weaponSplId,
				updatedSince: RECENT_PATCHES.at(-1)!.date,
			}),
	);
	add(
		"BuildRepository.findPageByWeaponId",
		fx.heavyWeaponSplId,
		(weaponSplId) =>
			BuildRepository.findPageByWeaponId({
				weaponId: weaponSplId,
				filters: { abilities: [], mode: null, date: null },
				page: 1,
				sortAbilities: true,
			}),
	);
	// pages by author, so the authors before the page are read off the index first
	add(
		"BuildRepository.findPageByWeaponId.deepPage",
		fx.heavyWeaponSplId,
		(weaponSplId) =>
			BuildRepository.findPageByWeaponId({
				weaponId: weaponSplId,
				filters: { abilities: [], mode: null, date: null },
				page: 50,
				sortAbilities: true,
			}),
	);
	// rare abilities match almost nothing, so every build of the weapon is checked
	add(
		"BuildRepository.findPageByWeaponId.rareFilters",
		fx.heavyWeaponSplId,
		(weaponSplId) =>
			BuildRepository.findPageByWeaponId({
				weaponId: weaponSplId,
				filters: {
					abilities: [
						{ type: "HAS", ability: "AD" },
						{ type: "HAS", ability: "TI" },
						{ type: "HAS", ability: "RP" },
					],
					mode: "TC",
					date: null,
				},
				page: 1,
				sortAbilities: true,
			}),
	);
	add(
		"BuildRepository.findPageByWeaponId.apFilters",
		fx.heavyWeaponSplId,
		(weaponSplId) =>
			BuildRepository.findPageByWeaponId({
				weaponId: weaponSplId,
				filters: {
					abilities: [
						{ type: "AT_LEAST", ability: "ISM", ap: 10 },
						{ type: "AT_MOST", ability: "SSU", ap: 6 },
						{ type: "HAS_NOT", ability: "LDE" },
					],
					mode: null,
					date: null,
				},
				page: 1,
				sortAbilities: true,
			}),
	);
	add("BuildRepository.findPageByUserId", fx.heavyBuildUserId, (userId) =>
		BuildRepository.findPageByUserId({
			userId,
			showPrivate: true,
			filters: {
				abilities: [],
				mode: null,
				date: null,
				weaponId: null,
				visibility: null,
			},
			sorting: {
				buildSorting: [
					"WEAPON_POOL",
					"MODE",
					"TOP_500",
					"WEAPON_IN_GAME_ORDER",
					"UPDATED_AT",
				],
				weaponPool: [40, 1010, 2070, 3010],
			},
			page: 1,
			sortAbilities: true,
		}),
	);
	add(
		"BuildRepository.findPageByUserId.rareFilters",
		fx.heavyBuildUserId,
		(userId) =>
			BuildRepository.findPageByUserId({
				userId,
				showPrivate: true,
				filters: {
					abilities: [
						{ type: "HAS", ability: "AD" },
						{ type: "HAS", ability: "TI" },
						{ type: "HAS", ability: "RP" },
					],
					mode: "TC",
					date: null,
					weaponId: null,
					visibility: null,
				},
				sorting: { buildSorting: null, weaponPool: [40] },
				page: 1,
				sortAbilities: true,
			}),
	);
	add("BuildRepository.countsByUserId", fx.heavyBuildUserId, (userId) =>
		BuildRepository.countsByUserId(userId, { showPrivate: true }),
	);
	addStatic("BuildRepository.countAllPublicByWeaponId", () =>
		BuildRepository.countAllPublicByWeaponId(),
	);

	add(
		"CalendarRepository.findAllBetweenTwoTimestamps",
		fx.calendarWindow,
		(window) => CalendarRepository.findAllBetweenTwoTimestamps(window),
	);
	add("CalendarRepository.findById", fx.heavyCalendarEventId, (eventId) =>
		CalendarRepository.findById(eventId, {
			includeMapPool: true,
			includeBadgePrizes: true,
		}),
	);
	add(
		"CalendarRepository.findAvatarImgIds",
		both(fx.heavyCalendarEventId, fx.heavyTournamentId),
		([eventId, tournamentId]) =>
			CalendarRepository.findAvatarImgIds({ eventId, tournamentId }),
	);
	add(
		"CalendarRepository.findRecentTournamentsByOrganizerUserId",
		fx.calendarAuthorId,
		(authorId) =>
			CalendarRepository.findRecentTournamentsByOrganizerUserId(authorId),
	);
	add("CalendarRepository.findResultsByEventId", fx.resultsEventId, (eventId) =>
		CalendarRepository.findResultsByEventId(eventId),
	);
	add(
		"CalendarRepository.findTopThreeResultsByEventIds",
		fx.resultsEventId,
		(eventId) => CalendarRepository.findTopThreeResultsByEventIds([eventId]),
	);

	add("ChatRepository.findAllRoomsByIds", fx.heavyChatUsers, (chatUsers) =>
		ChatRepository.findAllRoomsByIds(chatUsers.busiest.openRoomIds),
	);
	add(
		"ChatRepository.findAllOpenRoomIdsByUserId.busiest",
		fx.heavyChatUsers,
		(chatUsers) =>
			ChatRepository.findAllOpenRoomIdsByUserId(chatUsers.busiest.id),
	);
	add(
		"ChatRepository.findAllOpenRoomIdsByUserId.mostConnected",
		fx.heavyChatUsers,
		(chatUsers) =>
			ChatRepository.findAllOpenRoomIdsByUserId(chatUsers.mostConnectedId),
	);
	add("ChatRepository.findAllMessagesByRoomId", fx.heavyChatRoomId, (roomId) =>
		ChatRepository.findAllMessagesByRoomId(roomId),
	);
	add("ChatRepository.findMessageById", fx.heavyChatMessageId, (messageId) =>
		ChatRepository.findMessageById(messageId),
	);
	add(
		"ChatRepository.findAllParticipantsByUserIds",
		fx.manyUserIds,
		(userIds) => ChatRepository.findAllParticipantsByUserIds(userIds),
	);
	add(
		"ChatRepository.findMessageStatsByRoomIds",
		fx.heavyChatUsers,
		(chatUsers) =>
			ChatRepository.findMessageStatsByRoomIds(
				chatUsers.busiest.id,
				chatUsers.busiest.openRoomIds,
			),
	);

	// a tournament match room is the costliest to resolve: its owner join carries
	// the team members and the tournament's organizer permissions on top
	add(
		"ChatRoomResolver.resolve",
		fx.openChatRoomIdsByType?.TOURNAMENT_MATCH ?? null,
		(roomIds) => ChatRoomResolver.resolve(roomIds[0]),
	);
	add("ChatRoomResolver.findAllByUserId", fx.heavyChatUsers, (chatUsers) =>
		ChatRoomResolver.findAllByUserId(chatUsers.busiest.id),
	);

	// FeedRepository
	add("FeedRepository.findUsersByIds", fx.manyUserIds, (userIds) =>
		FeedRepository.findUsersByIds(userIds),
	);
	add("FeedRepository.findTournamentsByIds", fx.recentTournamentIds, (ids) =>
		FeedRepository.findTournamentsByIds(ids),
	);
	add(
		"FeedRepository.findTournamentTeamsByIds",
		fx.manyTournamentTeamIds,
		(ids) => FeedRepository.findTournamentTeamsByIds(ids),
	);
	add("FeedRepository.findTeamsByIds", fx.manyTeamIds, (teamIds) =>
		FeedRepository.findTeamsByIds(teamIds),
	);
	add("FeedRepository.findCommentAuthorsByIds", fx.manyUserIds, (userIds) =>
		FeedRepository.findCommentAuthorsByIds(userIds),
	);
	addStatic("FeedRepository.findLatestGroupMatchCreatedAt", () =>
		FeedRepository.findLatestGroupMatchCreatedAt(),
	);
	add("FeedRepository.findLatestSkillCreatedAt", fx.feedSq, (sq) =>
		FeedRepository.findLatestSkillCreatedAt(sq),
	);
	add(
		"FeedRepository.findMatchTimesByUserId",
		both(fx.feedSq, fx.feedNow),
		([sq, now]) =>
			FeedRepository.findMatchTimesByUserId({
				userId: sq.userId,
				after: now - FEED_ROTATION_LOOKBACK_WEEKS * 7 * DAY,
			}),
	);
	add("FeedRepository.findMapResultsByUserId", fx.feedSq, (sq) =>
		FeedRepository.findMapResultsByUserId(sq),
	);
	add("FeedRepository.findTopCloseRivalryOfUsers", fx.feedSq, (sq) =>
		FeedRepository.findTopCloseRivalryOfUsers({
			userIds: [sq.userId],
			season: sq.season,
		}),
	);
	add(
		"FeedRepository.findTopTeammatesByUserId",
		fx.topTeammatesUserId,
		(userId) => FeedRepository.findTopTeammatesByUserId(userId),
	);
	add("FeedRepository.findWeaponPicksByUser", fx.feedNow, (now) =>
		FeedRepository.findWeaponPicksByUser({ from: now - 7 * DAY, to: now }),
	);
	add("FeedRepository.findAllLobbiesEndedAfter", fx.feedNow, (now) =>
		FeedRepository.findAllLobbiesEndedAfter(
			now - FEED_RECENT_ACTIVITY_DAYS * DAY,
		),
	);
	add(
		"FeedRepository.findTournamentMatchesByTeamId",
		both(fx.heavyTournamentId, fx.heavyTournamentTeamId),
		([tournamentId, tournamentTeamId]) =>
			FeedRepository.findTournamentMatchesByTeamId({
				tournamentId,
				tournamentTeamId,
			}),
	);
	add(
		"FeedRepository.findFinishedMatchesByTournamentIds",
		fx.recentTournamentIds,
		(ids) => FeedRepository.findFinishedMatchesByTournamentIds(ids),
	);
	add(
		"FeedRepository.findSeedsByTournamentTeamIds",
		fx.manyTournamentTeamIds,
		(ids) => FeedRepository.findSeedsByTournamentTeamIds(ids),
	);
	add("FeedRepository.findAllUpcomingRegistrations", fx.feedNow, (now) =>
		FeedRepository.findAllUpcomingRegistrations(now),
	);
	add("FeedRepository.findAllLookingTournamentTeams", fx.feedNow, (now) =>
		FeedRepository.findAllLookingTournamentTeams(now),
	);
	add(
		"FeedRepository.findLatestOrganizationTournamentStartingBetween",
		fx.feedNow,
		(now) =>
			FeedRepository.findLatestOrganizationTournamentStartingBetween({
				from: now + 7 * DAY,
				to: now + 60 * DAY,
			}),
	);
	add(
		"FeedRepository.findAllOrganizationTournamentsAddedAfter",
		fx.feedNow,
		(now) =>
			FeedRepository.findAllOrganizationTournamentsAddedAfter(
				now - FEED_EVENT_MAX_RETENTION_DAYS * DAY,
			),
	);
	add(
		"FeedRepository.findOrganizationIdsPlayedByUserId",
		both(fx.heavyUser, fx.feedNow),
		([user, now]) =>
			FeedRepository.findOrganizationIdsPlayedByUserId({
				userId: user.id,
				after: now - 365 * DAY,
			}),
	);
	addStatic("FeedRepository.findSeriesWithLeaderboard", () =>
		FeedRepository.findSeriesWithLeaderboard(),
	);
	add(
		"FeedRepository.findSeriesEventsWithResults",
		both(fx.heavySeries, fx.feedNow),
		([series, now]) =>
			FeedRepository.findSeriesEventsWithResults({
				...series,
				from: now - FEED_SERIES_STANDINGS_DAYS * DAY,
				to: now,
			}),
	);
	add(
		"FeedRepository.findResultUserIds",
		both(fx.recentTournamentIds, fx.resultsEventId),
		([tournamentIds, eventId]) =>
			FeedRepository.findResultUserIds({
				tournamentIds,
				calendarEventIds: [eventId],
			}),
	);
	add("FeedRepository.findOrganizationById", fx.heavyOrg, (org) =>
		FeedRepository.findOrganizationById(org.id),
	);
	addStatic("FeedRepository.findLatestTournamentMatchVods", () =>
		FeedRepository.findLatestTournamentMatchVods(),
	);
	add(
		"FeedRepository.findAllTournamentBadgeOwnersStartedAfter",
		fx.feedNow,
		(now) =>
			FeedRepository.findAllTournamentBadgeOwnersStartedAfter(
				now - FEED_EVENT_MAX_RETENTION_DAYS * DAY,
			),
	);
	addStatic("FeedRepository.findLatestTrophyOwners", () =>
		FeedRepository.findLatestTrophyOwners(),
	);
	add("FeedRepository.findAllNewTrophiesAcceptedAfter", fx.feedNow, (now) =>
		FeedRepository.findAllNewTrophiesAcceptedAfter(
			now - FEED_RECENT_ACTIVITY_DAYS * DAY,
		),
	);
	add("FeedRepository.findAllUpcomingTournamentSaves.all", fx.feedNow, (now) =>
		FeedRepository.findAllUpcomingTournamentSaves({ after: now }),
	);
	add(
		"FeedRepository.findAllUpcomingTournamentSaves.ofUsers",
		both(fx.manyUserIds, fx.feedNow),
		([userIds, now]) =>
			FeedRepository.findAllUpcomingTournamentSaves({ after: now, userIds }),
	);
	add("FeedRepository.findAllUpcomingStaff", fx.feedNow, (now) =>
		FeedRepository.findAllUpcomingStaff(now - 2 * DAY),
	);
	add(
		"FeedRepository.findBiggestFinalizedTournaments.lastWeek",
		fx.feedNow,
		(now) =>
			FeedRepository.findBiggestFinalizedTournaments({
				from: now - 7 * DAY,
				to: now,
				limit: 10,
			}),
	);
	add(
		"FeedRepository.findBiggestFinalizedTournaments.onThisDay",
		fx.feedNow,
		(now) =>
			FeedRepository.findBiggestFinalizedTournaments({
				from: 0,
				to: now - 300 * DAY,
				monthDay: databaseTimestampToDate(now).toISOString().slice(5, 10),
				limit: 1,
			}),
	);
	add(
		"FeedRepository.findPodiumTeamIdsByTournamentId",
		fx.heavyResultsTournamentId,
		(tournamentId) =>
			FeedRepository.findPodiumTeamIdsByTournamentId(tournamentId),
	);
	add(
		"FeedRepository.findTournamentsWithRegistrationClosedBetween",
		fx.feedNow,
		(now) =>
			FeedRepository.findTournamentsWithRegistrationClosedBetween({
				from: now - 2 * DAY,
				to: now,
			}),
	);
	add(
		"FeedRepository.findRegisteredTeamsByTournamentId",
		fx.heavyTournamentId,
		(tournamentId) =>
			FeedRepository.findRegisteredTeamsByTournamentId(tournamentId),
	);
	add("FeedRepository.findSeriesByOrganizationId", fx.heavySeries, (series) =>
		FeedRepository.findSeriesByOrganizationId(series.organizationId),
	);
	add(
		"FeedRepository.countSeriesWinsOfUser",
		both(fx.heavySeries, both(fx.heavyUser, fx.feedNow)),
		([series, [user, now]]) =>
			FeedRepository.countSeriesWinsOfUser({
				...series,
				userId: user.id,
				before: now,
			}),
	);
	add("FeedRepository.findAllTeamJoinsAfter", fx.feedNow, (now) =>
		FeedRepository.findAllTeamJoinsAfter(now - FEED_RECENT_ACTIVITY_DAYS * DAY),
	);
	add("FeedRepository.findAllCreatedTeamsAfter", fx.feedNow, (now) =>
		FeedRepository.findAllCreatedTeamsAfter(
			now - FEED_RECENT_ACTIVITY_DAYS * DAY,
		),
	);
	add(
		"FeedRepository.findLatestTeamAvailabilityWeek.anyTeam",
		fx.feedNow,
		(now) =>
			FeedRepository.findLatestTeamAvailabilityWeek({
				before: now,
				minMembers: 4,
			}),
	);
	add(
		"FeedRepository.findLatestTeamAvailabilityWeek.ofTeams",
		both(fx.manyTeamIds, fx.feedNow),
		([teamIds, now]) =>
			FeedRepository.findLatestTeamAvailabilityWeek({
				before: now,
				minMembers: 4,
				teamIds,
			}),
	);
	add(
		"FeedRepository.findLatestAddedUpcomingTeamEvent.anyTeam",
		both(fx.heavyUser, fx.feedNow),
		([user, now]) =>
			FeedRepository.findLatestAddedUpcomingTeamEvent({
				now,
				excludeAuthorId: user.id,
			}),
	);
	add(
		"FeedRepository.findLatestAddedUpcomingTeamEvent.ofTeams",
		both(fx.heavyUser, both(fx.manyTeamIds, fx.feedNow)),
		([user, [teamIds, now]]) =>
			FeedRepository.findLatestAddedUpcomingTeamEvent({
				now,
				excludeAuthorId: user.id,
				teamIds,
			}),
	);
	add(
		"FeedRepository.findOpenScrimPostsForViewer",
		both(fx.heavyTeam, fx.feedNow),
		([team, now]) =>
			FeedRepository.findOpenScrimPostsForViewer({
				viewerId: team.memberUserId,
				excludedTeamIds: [team.id],
				now,
				lookingNowFrom: now - FEED_SCRIM_LOOKING_NOW_HOURS * HOUR,
				createdAfter:
					now -
					FEED_MAX_AGE_HALF_LIVES *
						FEED_ITEM_TYPES.SCRIM_POST.halfLifeHours *
						HOUR,
			}),
	);
	add("FeedRepository.findLatestUpcomingScrimPost", fx.feedNow, (now) =>
		FeedRepository.findLatestUpcomingScrimPost({
			from: now,
			to: now + 2 * DAY,
		}),
	);
	add(
		"FeedRepository.findAcceptedScrimsOfTeams",
		both(fx.manyTeamIds, fx.feedNow),
		([teamIds, now]) =>
			FeedRepository.findAcceptedScrimsOfTeams({
				teamIds,
				from: now - FEED_SCRIM_HISTORY_DAYS * DAY,
				to: now,
			}),
	);
	add("FeedRepository.findMemberLutiDivsByTeamIds", fx.manyTeamIds, (teamIds) =>
		FeedRepository.findMemberLutiDivsByTeamIds(teamIds),
	);
	add("FeedRepository.findLatestReportedScrim.anyTeam", fx.feedNow, (now) =>
		FeedRepository.findLatestReportedScrim({ before: now, minMaps: 5 }),
	);
	add(
		"FeedRepository.findLatestReportedScrim.ofTeams",
		both(fx.manyTeamIds, fx.feedNow),
		([teamIds, now]) =>
			FeedRepository.findLatestReportedScrim({
				before: now,
				minMaps: 5,
				teamIds,
			}),
	);
	add(
		"FeedRepository.findLFGPostsUpdatedBetween.playerForTeam",
		both(fx.heavyUser, fx.feedNow),
		([user, now]) =>
			FeedRepository.findLFGPostsUpdatedBetween({
				type: "PLAYER_FOR_TEAM",
				viewerId: user.id,
				from:
					now -
					FEED_MAX_AGE_HALF_LIVES *
						FEED_ITEM_TYPES.LFG_PLAYER.halfLifeHours *
						HOUR,
				to: now,
			}),
	);
	add(
		"FeedRepository.findLFGPostsUpdatedBetween.teamForPlayer",
		both(fx.heavyUser, fx.feedNow),
		([user, now]) =>
			FeedRepository.findLFGPostsUpdatedBetween({
				type: "TEAM_FOR_PLAYER",
				viewerId: user.id,
				from:
					now -
					FEED_MAX_AGE_HALF_LIVES *
						FEED_ITEM_TYPES.LFG_TEAM.halfLifeHours *
						HOUR,
				to: now,
			}),
	);
	add("FeedRepository.findLFGPostsByAuthorId", fx.lfgAuthorId, (authorId) =>
		FeedRepository.findLFGPostsByAuthorId({ authorId, after: 0 }),
	);
	add("FeedRepository.findWeaponPoolByUserId", fx.heavyUser, (user) =>
		FeedRepository.findWeaponPoolByUserId(user.id),
	);
	addStatic("FeedRepository.findAllTeamMemberships", () =>
		FeedRepository.findAllTeamMemberships(),
	);
	add("FeedRepository.countTournamentsByTeamId", fx.heavyTeam, (team) =>
		FeedRepository.countTournamentsByTeamId(team.id),
	);
	add("FeedRepository.findAllArtistsActiveBetween", fx.feedNow, (now) =>
		FeedRepository.findAllArtistsActiveBetween({
			from: now - 7 * DAY,
			to: now,
		}),
	);
	add(
		"FeedRepository.findArtPiecesOfAuthorBetween",
		both(fx.heavyArtUserId, fx.feedNow),
		([authorId, now]) =>
			FeedRepository.findArtPiecesOfAuthorBetween({
				authorId,
				from: 0,
				to: now,
			}),
	);
	add("FeedRepository.findAllTaggedArtAfter", fx.feedNow, (now) =>
		FeedRepository.findAllTaggedArtAfter(now - FEED_RECENT_ACTIVITY_DAYS * DAY),
	);
	add("FeedRepository.findAllOpenedCommissionsAfter", fx.feedNow, (now) =>
		FeedRepository.findAllOpenedCommissionsAfter(
			now - FEED_RECENT_ACTIVITY_DAYS * DAY,
		),
	);
	add("FeedRepository.findAllPublicBuildIdsUpdatedAfter", fx.feedNow, (now) =>
		FeedRepository.findAllPublicBuildIdsUpdatedAfter(
			now - FEED_RECENT_ACTIVITY_DAYS * DAY,
		),
	);
	add("FeedRepository.findBuildById", fx.buildId, (buildId) =>
		FeedRepository.findBuildById(buildId),
	);
	addStatic("FeedRepository.findLatestBuildIdsOfHighXpOwners", () =>
		FeedRepository.findLatestBuildIdsOfHighXpOwners(FEED_HIGH_XP),
	);
	add("FeedRepository.findLatestValidatedVideo", fx.feedNow, (now) =>
		FeedRepository.findLatestValidatedVideo(now),
	);
	addStatic("FeedRepository.findAllUserPlacementsOfLatestMonth", () =>
		FeedRepository.findAllUserPlacementsOfLatestMonth(),
	);
	add(
		"FeedRepository.findAllScannedMatchIdsWithReplayCode",
		fx.feedNow,
		(now) => FeedRepository.findAllScannedMatchIdsWithReplayCode(now),
	);
	add("FeedRepository.findScannedMatchById", fx.scannedMatchId, (id) =>
		FeedRepository.findScannedMatchById(id),
	);
	add("FeedRepository.findAllFriendshipsCreatedAfter", fx.feedNow, (now) =>
		FeedRepository.findAllFriendshipsCreatedAfter(
			now - FEED_RECENT_ACTIVITY_DAYS * DAY,
		),
	);
	add("FeedRepository.findPlusTierByUserId", fx.plusTierOneUser, (user) =>
		FeedRepository.findPlusTierByUserId(user.id),
	);
	add(
		"FeedRepository.findAllFirstPlusSuggestionsOfMonth",
		fx.plusSuggestionMonthYear,
		(monthYear) => FeedRepository.findAllFirstPlusSuggestionsOfMonth(monthYear),
	);
	add(
		"FeedRepository.findFirstTournamentResultByUserId",
		fx.heavyUser,
		(user) => FeedRepository.findFirstTournamentResultByUserId(user.id),
	);
	add(
		"FeedRepository.findLatestAddedUpcomingCalendarEvent",
		fx.feedNow,
		(now) => FeedRepository.findLatestAddedUpcomingCalendarEvent(now),
	);
	for (const total of FEED_SITE_TOTALS) {
		add(`FeedRepository.countSiteTotal.${total}`, fx.feedNow, (now) =>
			FeedRepository.countSiteTotal({ total, before: now }),
		);
		add(
			`FeedRepository.findNthOfSiteTotal.${total}`,
			fx.siteTotalCounts,
			(counts) =>
				FeedRepository.findNthOfSiteTotal({ total, nth: counts[total] }),
		);
	}

	// FeedEventRepository
	add(
		"FeedEventRepository.findAllByUserIds",
		both(fx.feedEventUserIds, fx.feedNow),
		([userIds, now]) =>
			FeedEventRepository.findAllByUserIds({
				userIds,
				from: now - FEED_EVENT_MAX_RETENTION_DAYS * DAY,
				to: now,
			}),
	);
	addStatic("FeedEventRepository.findCursorBySource.sq", () =>
		FeedEventRepository.findCursorBySource("SQ"),
	);
	addStatic("FeedEventRepository.findCursorBySource.tournament", () =>
		FeedEventRepository.findCursorBySource("TOURNAMENT"),
	);
	add(
		"FeedEventRepository.findUserIdsOfMatchesConfirmedSince",
		fx.feedNow,
		(now) =>
			FeedEventRepository.findUserIdsOfMatchesConfirmedSince(
				now - FEED_EVENT_MAX_RETENTION_DAYS * DAY,
			),
	);
	add(
		"FeedEventRepository.findUserIdsOfTournamentResultsAfterRowId",
		fx.feedIndexerTournamentResultRowId,
		(rowId) =>
			FeedEventRepository.findUserIdsOfTournamentResultsAfterRowId(rowId),
	);
	add(
		"FeedEventRepository.findUserIdsOfTournamentsStartedSince",
		fx.feedNow,
		(now) =>
			FeedEventRepository.findUserIdsOfTournamentsStartedSince(
				now - FEED_EVENT_MAX_RETENTION_DAYS * DAY,
			),
	);
	addStatic("FeedEventRepository.findLatestTournamentResultRowId", () =>
		FeedEventRepository.findLatestTournamentResultRowId(),
	);
	add("FeedEventRepository.findAllSqPlaysByUserId", fx.sq, (sq) =>
		FeedEventRepository.findAllSqPlaysByUserId(sq.userId),
	);
	add(
		"FeedEventRepository.findAllTournamentPlaysByUserId",
		fx.heavyUser,
		(user) => FeedEventRepository.findAllTournamentPlaysByUserId(user.id),
	);

	// FeedCommentRepository
	add("FeedCommentRepository.findByItemId", fx.feedCommentItemIds, (itemIds) =>
		FeedCommentRepository.findByItemId(itemIds[0]),
	);
	add(
		"FeedCommentRepository.countByItemIds",
		fx.feedCommentItemIds,
		(itemIds) => FeedCommentRepository.countByItemIds(itemIds),
	);

	// FeedReactionRepository
	add(
		"FeedReactionRepository.findByItemIds",
		both(fx.feedReactionItemIds, fx.heavyUser),
		([itemIds, user]) =>
			FeedReactionRepository.findByItemIds({ itemIds, userId: user.id }),
	);

	add("FriendRepository.findByUserIdWithActivity", fx.heavyFriendPair, (pair) =>
		FriendRepository.findByUserIdWithActivity(pair.userId),
	);
	add("FriendRepository.findPendingSentRequests", fx.heavyFriendPair, (pair) =>
		FriendRepository.findPendingSentRequests(pair.userId),
	);
	add(
		"FriendRepository.findPendingReceivedRequests",
		fx.heavyFriendPair,
		(pair) => FriendRepository.findPendingReceivedRequests(pair.userId),
	);
	add(
		"FriendRepository.findPendingReceivedRequestIds",
		fx.heavyFriendPair,
		(pair) => FriendRepository.findPendingReceivedRequestIds(pair.userId),
	);
	add("FriendRepository.countPendingSentRequests", fx.heavyFriendPair, (pair) =>
		FriendRepository.countPendingSentRequests(pair.userId),
	);
	add("FriendRepository.findFriendsByUserId", fx.heavyFriendPair, (pair) =>
		FriendRepository.findFriendsByUserId(pair.userId),
	);
	add("FriendRepository.findFriendIds", fx.heavyFriendPair, (pair) =>
		FriendRepository.findFriendIds(pair.userId),
	);
	add("FriendRepository.findFriendRequestBetween", fx.heavyFriendPair, (pair) =>
		FriendRepository.findFriendRequestBetween({
			senderId: pair.userId,
			receiverId: pair.otherUserId,
		}),
	);
	add("FriendRepository.findMutualFriends", fx.heavyFriendPair, (pair) =>
		FriendRepository.findMutualFriends({
			loggedInUserId: pair.userId,
			targetUserId: pair.otherUserId,
		}),
	);
	add("FriendRepository.findFriendship", fx.heavyFriendPair, (pair) =>
		FriendRepository.findFriendship({
			userOneId: pair.userId,
			userTwoId: pair.otherUserId,
		}),
	);
	add(
		"FriendRepository.findFriendRequestByIdAndReceiver",
		fx.friendRequest,
		(request) => FriendRepository.findFriendRequestByIdAndReceiver(request),
	);

	add("ImageRepository.findById", fx.imageId, (imageId) =>
		ImageRepository.findById(imageId),
	);
	add("ImageRepository.countUnvalidatedArt", fx.heavyArtUserId, (userId) =>
		ImageRepository.countUnvalidatedArt(userId),
	);
	addStatic("ImageRepository.countAllUnvalidated", () =>
		ImageRepository.countAllUnvalidated(),
	);
	addStatic("ImageRepository.findAllUnvalidated", () =>
		ImageRepository.findAllUnvalidated(),
	);
	add(
		"ImageRepository.countUnvalidatedBySubmitterUserId",
		fx.imageSubmitterId,
		(userId) => ImageRepository.countUnvalidatedBySubmitterUserId(userId),
	);

	add("LeaderboardRepository.findTeamLeaderboardBySeason", fx.sq, (sq) =>
		LeaderboardRepository.findTeamLeaderboardBySeason({
			season: sq.season,
			onlyOneEntryPerUser: true,
		}),
	);
	add("LeaderboardRepository.findSeasonsParticipatedInByUserId", fx.sq, (sq) =>
		LeaderboardRepository.findSeasonsParticipatedInByUserId(sq.userId),
	);
	addStatic("LeaderboardRepository.findAllXPLeaderboard", () =>
		LeaderboardRepository.findAllXPLeaderboard(),
	);
	addStatic("LeaderboardRepository.findModeXPLeaderboard", () =>
		LeaderboardRepository.findModeXPLeaderboard("SZ"),
	);
	add(
		"LeaderboardRepository.findWeaponXPLeaderboard",
		fx.heavyWeaponSplId,
		(weaponSplId) => LeaderboardRepository.findWeaponXPLeaderboard(weaponSplId),
	);
	add("LeaderboardRepository.findUserSPLeaderboard", fx.sq, (sq) =>
		LeaderboardRepository.findUserSPLeaderboard(sq.season),
	);
	add("LeaderboardRepository.findSeasonPopularUsersWeapon", fx.sq, (sq) =>
		LeaderboardRepository.findSeasonPopularUsersWeapon(sq.season),
	);

	addStatic("LFGRepository.findBoardPage", () =>
		LFGRepository.findBoardPage({
			filters: LFG_NO_FILTERS,
			page: 1,
			pageSize: 24,
			containingPostId: null,
		}),
	);
	add("LFGRepository.findBoardPage.containing", fx.lfgPostId, (postId) =>
		LFGRepository.findBoardPage({
			filters: LFG_NO_FILTERS,
			page: 1,
			pageSize: 24,
			containingPostId: postId,
		}),
	);
	addStatic("LFGRepository.findBoardPage.filtered", () =>
		LFGRepository.findBoardPage({
			filters: {
				...LFG_NO_FILTERS,
				weapons: [40, 1010],
				plusTier: 3,
				language: "en",
			},
			page: 1,
			pageSize: 24,
			containingPostId: null,
		}),
	);
	add("LFGRepository.findVisibleById", fx.lfgPostId, (postId) =>
		LFGRepository.findVisibleById(postId),
	);
	addStatic("LFGRepository.findAllOwn", () => LFGRepository.findAllOwn());
	addStatic("LFGRepository.findAllVisibleParticipantIds", () =>
		LFGRepository.findAllVisibleParticipantIds(),
	);
	add("LFGRepository.findByAuthorUserId", fx.lfgAuthorId, (authorId) =>
		LFGRepository.findByAuthorUserId(authorId),
	);

	add("LobbyRepository.findById", fx.heavyLobby, (lobby) =>
		LobbyRepository.findById(lobby.id),
	);
	add("LobbyRepository.isLinkOnlyById", fx.heavyLobby, (lobby) =>
		LobbyRepository.isLinkOnlyById(lobby.id),
	);
	add("LobbyRepository.findVisibilityRowsById", fx.heavyLobby, (lobby) =>
		LobbyRepository.findVisibilityRowsById(lobby.id),
	);
	add(
		"LobbyRepository.findAllVisible",
		both(fx.heavyUser, fx.heavyLobby),
		([user, lobby]) =>
			LobbyRepository.findAllVisible({
				userId: user.id,
				lobbyIds: [lobby.id],
			}),
	);
	add("LobbyRepository.findProgressionStateById", fx.heavyLobby, (lobby) =>
		LobbyRepository.findProgressionStateById(lobby.id),
	);
	add(
		"LobbyRepository.findAllByChatRoomIds",
		fx.openChatRoomIdsByType?.LOBBY ?? null,
		(roomIds) => LobbyRepository.findAllByChatRoomIds(roomIds),
	);
	addStatic("LobbyRepository.findAllForIndex", () =>
		LobbyRepository.findAllForIndex(),
	);
	add("LobbyRepository.findAllUpcomingByUserId", fx.heavyUser, (user) =>
		LobbyRepository.findAllUpcomingByUserId({
			userId: user.id,
			startsBefore: Number.MAX_SAFE_INTEGER,
		}),
	);
	addStatic("LobbyRepository.findAllActiveParticipants", () =>
		LobbyRepository.findAllActiveParticipants(),
	);
	addStatic("LobbyRepository.findAllUnconfirmedReadyCheckUsers", () =>
		LobbyRepository.findAllUnconfirmedReadyCheckUsers(),
	);
	add(
		"LobbyRepository.findAllUpcomingOfFriendsByUserId",
		fx.heavyUser,
		(user) => LobbyRepository.findAllUpcomingOfFriendsByUserId(user.id),
	);
	add("LobbyRepository.findResultPlacementsByUserId", fx.heavyUser, (user) =>
		LobbyRepository.findResultPlacementsByUserId(user.id),
	);
	addStatic("LobbyRepository.findAllUnendedIdsNearStart", () =>
		LobbyRepository.findAllUnendedIdsNearStart(),
	);

	add("LobbyMatchRepository.findAllSetsByLobbyId", fx.heavyLobby, (lobby) =>
		LobbyMatchRepository.findAllSetsByLobbyId(lobby.id),
	);
	add(
		"LobbyMatchRepository.findAllTeamChatsByChatRoomIds",
		fx.openChatRoomIdsByType?.LOBBY_TEAM ?? null,
		(roomIds) => LobbyMatchRepository.findAllTeamChatsByChatRoomIds(roomIds),
	);

	add("LiveStreamRepository.findByUserId", fx.heavyUser, (user) =>
		LiveStreamRepository.findByUserId(user.id),
	);
	addStatic("LiveStreamRepository.findXRankStreams", () =>
		LiveStreamRepository.findXRankStreams(Seasons.currentOrPrevious()!.nth),
	);

	add("MatchProfileRepository.findSettingsByUserId", fx.heavyUser, (user) =>
		MatchProfileRepository.findSettingsByUserId(user.id),
	);
	add(
		"MatchProfileRepository.findMapModePreferencesByUserId",
		fx.heavyUser,
		(user) => MatchProfileRepository.findMapModePreferencesByUserId(user.id),
	);
	add("MatchProfileRepository.findWeaponPoolByUserId", fx.heavyUser, (user) =>
		MatchProfileRepository.findWeaponPoolByUserId(user.id),
	);
	add("MatchProfileRepository.findAllByUserIds", fx.manyUserIds, (userIds) =>
		MatchProfileRepository.findAllByUserIds(userIds.slice(0, 10)),
	);
	add(
		"MatchProfileRepository.findAllMapModePreferencesByUserIds",
		fx.manyUserIds,
		(userIds) =>
			MatchProfileRepository.findAllMapModePreferencesByUserIds(
				userIds.slice(0, 10),
			),
	);

	add("SkillRepository.findCurrentUserSkills", fx.skillBatch, (skillBatch) =>
		SkillRepository.findCurrentUserSkills({
			season: skillBatch.season,
			userIds: skillBatch.userIds,
		}),
	);
	add("SkillRepository.findCurrentTeamSkills", fx.skillBatch, (skillBatch) =>
		SkillRepository.findCurrentTeamSkills({
			season: skillBatch.season,
			identifiers: skillBatch.identifiers,
		}),
	);
	add(
		"SkillRepository.findOrderedUserOrdinalsBySeason",
		fx.skillBatch,
		(skillBatch) =>
			SkillRepository.findOrderedUserOrdinalsBySeason(skillBatch.season),
	);
	add("SkillRepository.existsBySeason", fx.skillBatch, (skillBatch) =>
		SkillRepository.existsBySeason(skillBatch.season),
	);
	add("SkillRepository.findSeedingSkills", fx.skillBatch, (skillBatch) =>
		SkillRepository.findSeedingSkills({
			type: "RANKED",
			userIds: skillBatch.userIds,
		}),
	);
	add("SkillRepository.findSeasonProgressionByUserId", fx.sq, (sq) =>
		SkillRepository.findSeasonProgressionByUserId(sq),
	);
	add("SkillRepository.findSeasonPeakOrdinalByUserId", fx.sq, (sq) =>
		SkillRepository.findSeasonPeakOrdinalByUserId(sq),
	);
	add("SkillRepository.findSeasonActiveDaysByUserId", fx.sq, (sq) =>
		SkillRepository.findSeasonActiveDaysByUserId(sq),
	);

	add("NotificationRepository.findByUserId", fx.notification, (notification) =>
		NotificationRepository.findByUserId(notification.userId, { limit: 50 }),
	);
	add("NotificationRepository.findAllByType", fx.notification, (notification) =>
		NotificationRepository.findAllByType(notification.type),
	);
	add(
		"NotificationRepository.findAllSubscriptionsByUserIds",
		fx.manyUserIds,
		(userIds) => NotificationRepository.findAllSubscriptionsByUserIds(userIds),
	);
	add(
		"NotificationRepository.findUserIdsWithUnseenByType",
		both(fx.manyUserIds, fx.heavyChatRoomId),
		([userIds, roomId]) =>
			NotificationRepository.findUserIdsWithUnseenByType({
				userIds,
				type: "CHAT_MENTION",
				meta: { roomId },
			}),
	);

	add(
		"PlusSuggestionRepository.findAllByMonth",
		fx.plusSuggestionMonthYear,
		(monthYear) => PlusSuggestionRepository.findAllByMonth(monthYear),
	);
	add(
		"PlusSuggestionRepository.findAllByMonth (one tier)",
		fx.plusSuggestionMonthYear,
		(monthYear) =>
			PlusSuggestionRepository.findAllByMonth({ ...monthYear, tier: 3 }),
	);
	add(
		"PlusSuggestionRepository.findMonthSummary",
		fx.plusSuggestionMonthYear && fx.heavyUser
			? { ...fx.plusSuggestionMonthYear, userId: fx.heavyUser.id }
			: null,
		(args) => PlusSuggestionRepository.findMonthSummary(args),
	);

	addStatic("PlusVotingRepository.findAllPlusTiersFromLatestVoting", () =>
		PlusVotingRepository.findAllPlusTiersFromLatestVoting(),
	);
	add("PlusVotingRepository.findResultsByMonthYear", fx.plusVoting, (voting) =>
		PlusVotingRepository.findResultsByMonthYear(voting),
	);
	add(
		"PlusVotingRepository.findAllUsersForVoting",
		fx.plusTierOneUser,
		(user) => PlusVotingRepository.findAllUsersForVoting(user),
	);
	add("PlusVotingRepository.hasVoted", fx.plusVoting, (voting) =>
		PlusVotingRepository.hasVoted({
			authorId: voting.voterId,
			month: voting.month,
			year: voting.year,
		}),
	);

	add(
		"ScannerIngestRepository.gamesPlayedByUserInTournament",
		fx.scannerIngest,
		(ingest) =>
			ScannerIngestRepository.gamesPlayedByUserInTournament({
				userId: ingest.povUserId,
				tournamentId: ingest.tournamentId,
			}),
	);
	add(
		"ScannerIngestRepository.gamesPlayedByUserSince",
		fx.scannerIngest,
		(ingest) =>
			ScannerIngestRepository.gamesPlayedByUserSince({
				userId: ingest.povUserId,
				since: ingest.sinceTimestamp,
			}),
	);
	add(
		"ScannerIngestRepository.castedGamesInTournament",
		fx.castedTournamentId,
		(tournamentId) =>
			ScannerIngestRepository.castedGamesInTournament(tournamentId),
	);
	add(
		"ScannerIngestRepository.gamesInGroupMatch",
		fx.heavyGroupMatchId,
		(groupMatchId) => ScannerIngestRepository.gamesInGroupMatch(groupMatchId),
	);
	add(
		"ScannerIngestRepository.sendouqGamesPlayedByUserSince",
		fx.scannerIngestSendouq,
		(sendouq) =>
			ScannerIngestRepository.sendouqGamesPlayedByUserSince({
				userId: sendouq.userId,
				since: sendouq.sinceTimestamp,
			}),
	);
	add(
		"ScannerIngestRepository.tournamentActivityAt",
		fx.scannerIngest,
		(ingest) =>
			ScannerIngestRepository.tournamentActivityAt({
				userId: ingest.povUserId,
				at: ingest.atMs,
			}),
	);
	add(
		"ScannerIngestRepository.groupMatchIdAt",
		fx.scannerIngestSendouq,
		(sendouq) =>
			ScannerIngestRepository.groupMatchIdAt({
				userId: sendouq.userId,
				at: sendouq.atMs,
			}),
	);
	add(
		"ScannerIngestRepository.staffTournamentIdsAt",
		both(fx.calendarAuthorId, fx.scannerIngest),
		([userId, ingest]) =>
			ScannerIngestRepository.staffTournamentIdsAt({
				userId,
				at: ingest.atMs,
			}),
	);
	add(
		"ScannerIngestRepository.findScoreboardsByTournamentMatchId",
		fx.heavyTournamentMatchId,
		(tournamentMatchId) =>
			ScannerIngestRepository.findScoreboardsByTournamentMatchId(
				tournamentMatchId,
			),
	);
	add(
		"ScannerIngestRepository.findScoreboardsByTournamentMatchIds",
		fx.heavyTournamentTeamMatchIds,
		(tournamentMatchIds) =>
			ScannerIngestRepository.findScoreboardsByTournamentMatchIds(
				tournamentMatchIds,
			),
	);
	add(
		"ScannerIngestRepository.findScoreboardsByGroupMatchId",
		fx.heavyGroupMatchId,
		(groupMatchId) =>
			ScannerIngestRepository.findScoreboardsByGroupMatchId(groupMatchId),
	);
	add(
		"ScannerIngestRepository.gamesInTournamentMatches",
		fx.heavyTournamentMatchId,
		(tournamentMatchId) =>
			ScannerIngestRepository.gamesInTournamentMatches([tournamentMatchId]),
	);

	add("ScannerIngestRepository.gamesInLobbySet", fx.heavyLobby, (lobby) =>
		ScannerIngestRepository.gamesInLobbySet(lobby.setId),
	);
	add(
		"ScannerIngestRepository.lobbyGamesPlayedByUserSince",
		fx.heavyLobby,
		(lobby) =>
			ScannerIngestRepository.lobbyGamesPlayedByUserSince({
				userId: lobby.userId,
				since: lobby.sinceTimestamp,
			}),
	);
	add("ScannerIngestRepository.lobbySetIdAt", fx.heavyLobby, (lobby) =>
		ScannerIngestRepository.lobbySetIdAt({
			userId: lobby.userId,
			at: lobby.atMs,
		}),
	);
	add(
		"ScannerIngestRepository.findScoreboardsByLobbyId",
		fx.heavyLobby,
		(lobby) => ScannerIngestRepository.findScoreboardsByLobbyId(lobby.id),
	);

	add(
		"ScrimMapListRepository.findMapListsByScrimPostId",
		fx.heavyScrimPostId,
		(scrimPostId) =>
			ScrimMapListRepository.findMapListsByScrimPostId(scrimPostId),
	);

	add(
		"ScrimMapRepository.findMapsByScrimPostId",
		fx.heavyScrimPostId,
		(scrimPostId) => ScrimMapRepository.findMapsByScrimPostId(scrimPostId),
	);

	add(
		"ScrimPostRepository.findAllByChatRoomIds",
		fx.openChatRoomIdsByType?.SCRIM ?? null,
		(roomIds) => ScrimPostRepository.findAllByChatRoomIds(roomIds),
	);
	add("ScrimPostRepository.findById", fx.heavyScrimPostId, (scrimPostId) =>
		ScrimPostRepository.findById(scrimPostId),
	);
	addStatic("ScrimPostRepository.findAllRelevant", () =>
		ScrimPostRepository.findAllRelevant(),
	);
	add(
		"ScrimPostRepository.findAllRelevant.byAssociation",
		fx.heavyAssociation,
		(association) => ScrimPostRepository.findAllRelevant(association.id),
	);
	add(
		"ScrimPostRepository.findAcceptedScrimsBetweenTwoTimestamps",
		fx.scrimWindow,
		(window) =>
			ScrimPostRepository.findAcceptedScrimsBetweenTwoTimestamps({
				startTime: window.startTime,
				endTime: window.endTime,
				excludeRecentlyCreated: window.endTime,
			}),
	);
	add(
		"ScrimPostRepository.findPendingOverlapsForUsers",
		both(fx.scrimUserIds, fx.scrimWindow),
		([userIds, window]) =>
			ScrimPostRepository.findPendingOverlapsForUsers({
				userIds,
				startTime: dateToDatabaseTimestamp(window.startTime),
				endTime: dateToDatabaseTimestamp(window.endTime),
				excludePostId: -1,
			}),
	);
	add("ScrimPostRepository.findUserScrims", fx.scrimUserIds, (userIds) =>
		ScrimPostRepository.findUserScrims(userIds[0]),
	);
	add(
		"ScrimPostRepository.findAllAcceptedByUserIds",
		both(fx.scrimUserIds, fx.scrimWindow),
		([userIds, window]) =>
			ScrimPostRepository.findAllAcceptedByUserIds({
				userIds,
				startsAt: dateToDatabaseTimestamp(window.startTime),
				endsAt: dateToDatabaseTimestamp(window.endTime),
			}),
	);

	add(
		"GroupMatchContinueVoteRepository.findAllByGroupIds",
		fx.heavyGroupIds,
		(groupIds) => GroupMatchContinueVoteRepository.findAllByGroupIds(groupIds),
	);

	add("PlayerStatRepository.findSeasonMapWinrateByUserId", fx.sq, (sq) =>
		PlayerStatRepository.findSeasonMapWinrateByUserId(sq),
	);
	add("PlayerStatRepository.findSeasonSetWinrateByUserId", fx.sq, (sq) =>
		PlayerStatRepository.findSeasonSetWinrateByUserId(sq),
	);
	add("PlayerStatRepository.findSeasonStagesByUserId", fx.sq, (sq) =>
		PlayerStatRepository.findSeasonStagesByUserId(sq),
	);
	add("PlayerStatRepository.findMapResultsByUserIdAndSeasons", fx.sq, (sq) =>
		PlayerStatRepository.findMapResultsByUserIdAndSeasons({
			userId: sq.userId,
			seasons: [sq.season, sq.season - 1, sq.season - 2, sq.season - 3],
		}),
	);
	add("PlayerStatRepository.findSeasonMatesEnemiesByUserId", fx.sq, (sq) =>
		PlayerStatRepository.findSeasonMatesEnemiesByUserId({
			...sq,
			type: "MATE",
		}),
	);
	add("PlayerStatRepository.findSeasonSetScoresByUserId", fx.sq, (sq) =>
		PlayerStatRepository.findSeasonSetScoresByUserId(sq),
	);
	add("PlayerStatRepository.findSeasonBestSetsByUserId", fx.sq, (sq) =>
		PlayerStatRepository.findSeasonBestSetsByUserId({ ...sq, limit: 3 }),
	);
	add("PlayerStatRepository.findSeasonTournamentRunsByUserId", fx.sq, (sq) =>
		PlayerStatRepository.findSeasonTournamentRunsByUserId(sq),
	);

	add("ReportedWeaponRepository.findAllByLobbyId", fx.heavyLobby, (lobby) =>
		ReportedWeaponRepository.findAllByLobbyId(lobby.id),
	);
	add(
		"ReportedWeaponRepository.findByMatchId",
		fx.heavyGroupMatchId,
		(matchId) => ReportedWeaponRepository.findByMatchId(matchId),
	);
	add(
		"ReportedWeaponRepository.findByTournamentMatchId",
		fx.heavyTournamentMatchId,
		(matchId) => ReportedWeaponRepository.findByTournamentMatchId(matchId),
	);
	add(
		"ReportedWeaponRepository.findByTournamentMatchIds",
		fx.heavyTournamentTeamMatchIds,
		(matchIds) => ReportedWeaponRepository.findByTournamentMatchIds(matchIds),
	);
	add(
		"ReportedWeaponRepository.findSeasonReportedWeaponsByUserId",
		fx.sq,
		(sq) => ReportedWeaponRepository.findSeasonReportedWeaponsByUserId(sq),
	);
	add(
		"ReportedWeaponRepository.findAllWeaponUsageStats",
		both(fx.sq, fx.heavyStageModeCombo),
		([sq, combo]) =>
			ReportedWeaponRepository.findAllWeaponUsageStats({
				userId: sq.userId,
				season: sq.season,
				mode: combo.mode,
				stageId: combo.stageId,
			}),
	);

	add(
		"SQMatchRepository.findAllByChatRoomIds",
		fx.openChatRoomIdsByType?.SQ_MATCH ?? null,
		(roomIds) => SQMatchRepository.findAllByChatRoomIds(roomIds),
	);
	add("SQMatchRepository.findById", fx.heavyGroupMatchId, (matchId) =>
		SQMatchRepository.findById(matchId),
	);
	add("SQMatchRepository.findLiveStateById", fx.heavyGroupMatchId, (matchId) =>
		SQMatchRepository.findLiveStateById(matchId),
	);
	add("SQMatchRepository.countSeasonResultPagesByUserId", fx.sq, (sq) =>
		SQMatchRepository.countSeasonResultPagesByUserId(sq),
	);
	add("SQMatchRepository.findSeasonResultsByUserId", fx.sq, (sq) =>
		SQMatchRepository.findSeasonResultsByUserId({ ...sq, page: 1 }),
	);
	add("SQMatchRepository.findSeasonDaySummariesByUserId", fx.sq, (sq) =>
		SQMatchRepository.findSeasonDaySummariesByUserId({
			...sq,
			// every day of the season, the worst case of a page spanning it all
			dates: eachDayOfInterval({
				start: Seasons.nthToDateRange(sq.season).starts,
				end: Seasons.nthToDateRange(sq.season).ends,
			}).map(dateToYYYYMMDD),
		}),
	);
	add("SQMatchRepository.findSeasonCanceledMatchesByUserId", fx.sq, (sq) =>
		SQMatchRepository.findSeasonCanceledMatchesByUserId(sq),
	);
	add("ModAuditLogRepository.findSeasonByUserId", fx.sq, (sq) =>
		ModAuditLogRepository.findSeasonByUserId({
			...sq,
			type: "SENDOUQ_PUBLIC_NOTE",
		}),
	);
	add(
		"SQMatchRepository.findCancelReportsByGroupMatchId",
		fx.heavyGroupMatchId,
		(matchId) => SQMatchRepository.findCancelReportsByGroupMatchId(matchId),
	);
	add(
		"SQMatchRepository.findCancelNominationCountsByUserIds",
		both(fx.manyUserIds, fx.sq),
		([userIds, sq]) =>
			SQMatchRepository.findCancelNominationCountsByUserIds({
				userIds,
				season: sq.season,
			}),
	);

	addStatic("QStreamsRepository.findAllActiveMatchPlayers", () =>
		QStreamsRepository.findAllActiveMatchPlayers(),
	);

	// relies on the benchmark's actor context
	addStatic("PrivateUserNoteRepository.findAllOwn.all", () =>
		PrivateUserNoteRepository.findAllOwn(),
	);
	add(
		"PrivateUserNoteRepository.findAllOwn.byTargets",
		fx.manyUserIds,
		(userIds) => PrivateUserNoteRepository.findAllOwn(userIds),
	);

	add(
		"SQGroupRepository.findAllByChatRoomIds",
		fx.openChatRoomIdsByType?.SQ_GROUP ?? null,
		(roomIds) => SQGroupRepository.findAllByChatRoomIds(roomIds),
	);
	add(
		"SQGroupRepository.findMapModePreferencesByGroupId",
		fx.heavyGroupIds,
		(groupIds) =>
			SQGroupRepository.findMapModePreferencesByGroupId(groupIds[0]),
	);
	addStatic("SQGroupRepository.findCurrentGroups", () =>
		SQGroupRepository.findCurrentGroups(),
	);
	addStatic("SQGroupRepository.findActiveGroupMembers", () =>
		SQGroupRepository.findActiveGroupMembers(),
	);
	add("SQGroupRepository.findAllLikesByGroupId", fx.heavyGroupIds, (groupIds) =>
		SQGroupRepository.findAllLikesByGroupId(groupIds[0]),
	);
	add(
		"SQGroupRepository.findAllSuggestionsByGroupId",
		fx.heavyGroupIds,
		(groupIds) => SQGroupRepository.findAllSuggestionsByGroupId(groupIds[0]),
	);
	add(
		"SQGroupRepository.findAllMissedReadyCheckUserIdsByGroupId",
		fx.heavyGroupIds,
		(groupIds) =>
			SQGroupRepository.findAllMissedReadyCheckUserIdsByGroupId(groupIds[0]),
	);
	add(
		"SQGroupRepository.findReadyCheckByGroupId",
		fx.heavyGroupIds,
		(groupIds) => SQGroupRepository.findReadyCheckByGroupId(groupIds[0]),
	);
	addStatic("SQGroupRepository.findAllReadyChecksStartedBefore", () =>
		SQGroupRepository.findAllReadyChecksStartedBefore(new Date()),
	);
	add("SQGroupRepository.findFriendsAndTeammates", fx.sq, (sq) =>
		SQGroupRepository.findFriendsAndTeammates(sq.userId),
	);
	add("SQGroupRepository.findAllMapModePreferencesBySeasonNth", fx.sq, (sq) =>
		SQGroupRepository.findAllMapModePreferencesBySeasonNth(sq.season),
	);
	addStatic("SQGroupRepository.findRecentlyFinishedMatches", () =>
		SQGroupRepository.findRecentlyFinishedMatches(),
	);
	addStatic("SQGroupRepository.findCurrentReceivedLikerGroupIds", () =>
		SQGroupRepository.findCurrentReceivedLikerGroupIds(),
	);

	addStatic("SplatoonRotationRepository.findAll", () =>
		SplatoonRotationRepository.findAll(),
	);

	addStatic("TeamRepository.searchByName", () =>
		TeamRepository.searchByName(SEARCH_QUERY),
	);
	add("TeamRepository.findById", fx.heavyTeam, (team) =>
		TeamRepository.findById(team.id),
	);
	add("TeamRepository.findAllMemberOfByUserId", fx.heavyTeam, (team) =>
		TeamRepository.findAllMemberOfByUserId(team.memberUserId),
	);
	add("TeamRepository.findByCustomUrl", fx.heavyTeam, (team) =>
		TeamRepository.findByCustomUrl(team.customUrl, {
			includeInviteCode: true,
		}),
	);
	add("TeamRepository.findResultPlacementsById", fx.heavyTeam, (team) =>
		TeamRepository.findResultPlacementsById(team.id),
	);
	add("TeamRepository.findResultsById", fx.heavyTeam, (team) =>
		TeamRepository.findResultsById(team.id),
	);
	add("TeamRepository.findAllByMemberUserId", fx.heavyTeam, (team) =>
		TeamRepository.findAllByMemberUserId(team.memberUserId),
	);

	add("XRankPlacementRepository.isPlayerLinkedByUserId", fx.xrank, (xrank) =>
		XRankPlacementRepository.isPlayerLinkedByUserId(xrank.userId),
	);
	add(
		"XRankPlacementRepository.findTenStarWeaponSplIdsByUserId",
		fx.xrank,
		(xrank) =>
			XRankPlacementRepository.findTenStarWeaponSplIdsByUserId(xrank.userId),
	);
	add(
		"XRankPlacementRepository.findPeakVerifiedXpByUserId",
		fx.xrank,
		(xrank) =>
			XRankPlacementRepository.findPeakVerifiedXpByUserId(xrank.userId),
	);
	add("XRankPlacementRepository.findPlacementsOfMonth", fx.xrank, (xrank) =>
		XRankPlacementRepository.findPlacementsOfMonth({
			mode: xrank.mode,
			region: xrank.region,
			month: xrank.month,
			year: xrank.year,
		}),
	);
	add("XRankPlacementRepository.findPlacementsByPlayerId", fx.xrank, (xrank) =>
		XRankPlacementRepository.findPlacementsByPlayerId(xrank.playerId),
	);
	add("XRankPlacementRepository.findPlacementsByUserId", fx.xrank, (xrank) =>
		XRankPlacementRepository.findPlacementsByUserId(xrank.userId),
	);
	addStatic("XRankPlacementRepository.findAllMonthYears", () =>
		XRankPlacementRepository.findAllMonthYears(),
	);
	add("XRankPlacementRepository.findPeaksByUserId", fx.xrank, (xrank) =>
		XRankPlacementRepository.findPeaksByUserId(xrank.userId, "both"),
	);

	add(
		"BracketRepository.findByTournamentId",
		fx.heaviestBracketTournamentId,
		(tournamentId) => BracketRepository.findByTournamentId(tournamentId),
	);

	add(
		"TournamentMatchVodRepository.findVodsByTournamentId",
		fx.heavyTournamentId,
		(tournamentId) =>
			TournamentMatchVodRepository.findVodsByTournamentId(tournamentId),
	);
	addStatic("TournamentMatchVodRepository.findTournamentsNeedingVodSync", () =>
		TournamentMatchVodRepository.findTournamentsNeedingVodSync(),
	);
	add(
		"TournamentMatchVodRepository.findStreamersByTournamentId",
		fx.heavyTournamentId,
		(tournamentId) =>
			TournamentMatchVodRepository.findStreamersByTournamentId(tournamentId),
	);
	add(
		"TournamentMatchVodRepository.findMatchesWithStartedAt",
		fx.heavyTournamentId,
		(tournamentId) =>
			TournamentMatchVodRepository.findMatchesWithStartedAt(tournamentId),
	);
	add(
		"TournamentMatchVodRepository.findCastedMatchHistoryByTournamentId",
		fx.heavyTournamentId,
		(tournamentId) =>
			TournamentMatchVodRepository.findCastedMatchHistoryByTournamentId(
				tournamentId,
			),
	);

	add(
		"TournamentLFGRepository.findLookingTeamsByTournamentId",
		fx.lfgTournament,
		(lfg) =>
			TournamentLFGRepository.findLookingTeamsByTournamentId(lfg.tournamentId),
	);
	add("TournamentLFGRepository.findSubGroups", fx.lfgTournament, (lfg) =>
		TournamentLFGRepository.findSubGroups(lfg.tournamentId),
	);
	add("TournamentLFGRepository.findAllLikesByTeamId", fx.lfgTournament, (lfg) =>
		TournamentLFGRepository.findAllLikesByTeamId(lfg.teamId),
	);
	add(
		"TournamentLFGRepository.findAllSubsByTournamentId",
		fx.lfgTournament,
		(lfg) =>
			TournamentLFGRepository.findAllSubsByTournamentId(lfg.tournamentId),
	);

	add(
		"TournamentMatchRepository.findAllByChatRoomIds",
		fx.openChatRoomIdsByType?.TOURNAMENT_MATCH ?? null,
		(roomIds) => TournamentMatchRepository.findAllByChatRoomIds(roomIds),
	);
	add(
		"TournamentMatchRepository.findMatchById",
		fx.heavyTournamentMatchId,
		(matchId) => TournamentMatchRepository.findMatchById(matchId),
	);
	add(
		"TournamentMatchRepository.findResultById",
		fx.tournamentMatchGameResultId,
		(resultId) => TournamentMatchRepository.findResultById(resultId),
	);
	add(
		"TournamentMatchRepository.findResultsByMatchId",
		fx.heavyTournamentMatchId,
		(matchId) => TournamentMatchRepository.findResultsByMatchId(matchId),
	);
	add(
		"TournamentMatchRepository.findAllResultsByTournamentId",
		fx.heavyTournamentId,
		(tournamentId) =>
			TournamentMatchRepository.findAllResultsByTournamentId(tournamentId),
	);
	add(
		"TournamentMatchRepository.findUserParticipationByTournamentId",
		fx.heavyTournamentId,
		(tournamentId) =>
			TournamentMatchRepository.findUserParticipationByTournamentId(
				tournamentId,
			),
	);
	add(
		"TournamentMatchRepository.findByTournamentTeamId",
		fx.heavyTournamentTeamId,
		(tournamentTeamId) =>
			TournamentMatchRepository.findByTournamentTeamId(tournamentTeamId),
	);
	add(
		"TournamentMatchRepository.findScheduleProposalsByMatchId",
		fx.scheduleProposal?.matchId ?? fx.heavyTournamentMatchId,
		(matchId) =>
			TournamentMatchRepository.findScheduleProposalsByMatchId(matchId),
	);
	add(
		"TournamentMatchRepository.findLastResultAtsByTournamentId",
		fx.heaviestBracketTournamentId,
		(tournamentId) =>
			TournamentMatchRepository.findLastResultAtsByTournamentId(tournamentId),
	);
	add(
		"TournamentMatchRepository.findScheduledByUserIds",
		both(fx.manyUserIds, fx.availabilityWindow),
		([userIds, window]) =>
			TournamentMatchRepository.findScheduledByUserIds({
				userIds,
				startsAt: window.startsAt,
				endsAt: window.endsAt,
			}),
	);
	add(
		"TournamentMatchRepository.findScheduledByUserId",
		both(fx.heavyUser, fx.availabilityWindow),
		([user, window]) =>
			TournamentMatchRepository.findScheduledByUserId({
				userId: user.id,
				startsAt: window.startsAt,
				endsAt: window.endsAt,
			}),
	);
	add(
		"TournamentMatchRepository.findScheduledBetween",
		fx.availabilityWindow,
		(window) =>
			TournamentMatchRepository.findScheduledBetween({
				startsAt: window.startsAt,
				endsAt: window.endsAt,
			}),
	);
	add(
		"TournamentMatchRepository.findScheduleProposalById",
		fx.scheduleProposal,
		(proposal) =>
			TournamentMatchRepository.findScheduleProposalById(proposal.id),
	);

	add("TournamentOrganizationRepository.findBySlug", fx.heavyOrg, (org) =>
		TournamentOrganizationRepository.findBySlug(org.slug),
	);
	add("TournamentOrganizationRepository.findByUserId", fx.heavyOrg, (org) =>
		TournamentOrganizationRepository.findByUserId(org.memberUserId),
	);
	addStatic("TournamentOrganizationRepository.searchByName", () =>
		TournamentOrganizationRepository.searchByName(SEARCH_QUERY),
	);
	add(
		"TournamentOrganizationRepository.findEventsByMonth",
		fx.heavyOrg,
		(org) =>
			TournamentOrganizationRepository.findEventsByMonth({
				month: org.eventMonth,
				year: org.eventYear,
				organizationId: org.id,
			}),
	);
	add(
		"TournamentOrganizationRepository.findAllUnfinalizedEvents",
		fx.heavyOrg,
		(org) => TournamentOrganizationRepository.findAllUnfinalizedEvents(org.id),
	);
	add(
		"TournamentOrganizationRepository.findPaginatedEventsBySeries",
		fx.heavyOrg,
		(org) =>
			TournamentOrganizationRepository.findPaginatedEventsBySeries({
				organizationId: org.id,
				substringMatches: [org.seriesSubstring],
				page: 1,
			}),
	);
	add(
		"TournamentOrganizationRepository.findAllEventsBySeries",
		fx.heavyOrg,
		(org) =>
			TournamentOrganizationRepository.findAllEventsBySeries({
				organizationId: org.id,
				substringMatches: [org.seriesSubstring],
			}),
	);
	add(
		"TournamentOrganizationRepository.countActiveParticipants",
		fx.heavyOrg,
		(org) =>
			TournamentOrganizationRepository.countActiveParticipants({
				organizationId: org.id,
				startTime: org.windowStart,
				endTime: org.windowEnd,
			}),
	);
	add(
		"TournamentOrganizationRepository.findAllBannedUsersByOrganizationId",
		fx.heavyOrg,
		(org) =>
			TournamentOrganizationRepository.findAllBannedUsersByOrganizationId(
				org.id,
			),
	);
	add(
		"TournamentOrganizationRepository.isUserBannedByOrganization",
		both(fx.heavyOrg, fx.heavyUser),
		([org, user]) =>
			TournamentOrganizationRepository.isUserBannedByOrganization({
				organizationId: org.id,
				userId: user.id,
			}),
	);
	add(
		"TournamentOrganizationRepository.countOrganizationsByUserId",
		fx.heavyOrg,
		(org) =>
			TournamentOrganizationRepository.countOrganizationsByUserId(
				org.memberUserId,
			),
	);
	addStatic("TournamentOrganizationRepository.findAllSeries", () =>
		TournamentOrganizationRepository.findAllSeries(),
	);
	addStatic(
		"TournamentOrganizationRepository.findAllOrganizedTournamentTeamCounts",
		() =>
			TournamentOrganizationRepository.findAllOrganizedTournamentTeamCounts({
				startedAfter: dateToDatabaseTimestamp(subDays(new Date(), 90)),
			}),
	);

	add(
		"SavedCalendarEventRepository.isSaved",
		both(fx.heavyUser, fx.heavyTournamentId),
		([user, tournamentId]) =>
			SavedCalendarEventRepository.isSaved({
				userId: user.id,
				tournamentId,
			}),
	);
	add("SavedCalendarEventRepository.countByUserId", fx.heavyUser, (user) =>
		SavedCalendarEventRepository.countByUserId(user.id),
	);
	add(
		"SavedCalendarEventRepository.findAllUpcomingByUserId",
		fx.heavyUser,
		(user) => SavedCalendarEventRepository.findAllUpcomingByUserId(user.id),
	);

	add(
		"TournamentAuditLogRepository.findByTournamentId",
		fx.auditTournamentId,
		(tournamentId) =>
			TournamentAuditLogRepository.findByTournamentId({
				tournamentId,
				limit: TournamentAuditLogRepository.AUDIT_LOG_PAGE_SIZE,
				offset: 0,
			}),
	);
	add(
		"TournamentAuditLogRepository.countByTournamentId",
		fx.auditTournamentId,
		(tournamentId) =>
			TournamentAuditLogRepository.countByTournamentId({ tournamentId }),
	);
	add(
		"TournamentAuditLogRepository.findTeamsByTournamentId",
		fx.auditTournamentId,
		(tournamentId) =>
			TournamentAuditLogRepository.findTeamsByTournamentId(tournamentId),
	);

	add(
		"TournamentRepository.findOrganizerPermissionsByTournamentIds",
		fx.recentTournamentIds,
		(tournamentIds) =>
			TournamentRepository.findOrganizerPermissionsByTournamentIds(
				tournamentIds,
			),
	);
	add("TournamentRepository.findById", fx.heavyTournamentId, (tournamentId) =>
		TournamentRepository.findById(tournamentId),
	);
	add(
		"TournamentRepository.findStreamsByTournamentId",
		fx.heavyTournamentId,
		(tournamentId) =>
			TournamentRepository.findStreamsByTournamentId(tournamentId),
	);
	add(
		"TournamentRepository.findTeamsFullByTournamentId",
		fx.heavyTournamentId,
		(tournamentId) =>
			TournamentRepository.findTeamsFullByTournamentId(tournamentId),
	);
	add(
		"TournamentRepository.findParticipatedUserIdsById",
		fx.heavyTournamentId,
		(tournamentId) =>
			TournamentRepository.findParticipatedUserIdsById(tournamentId),
	);
	add(
		"TournamentRepository.findRulesById",
		fx.heavyTournamentId,
		(tournamentId) => TournamentRepository.findRulesById(tournamentId),
	);
	add(
		"TournamentRepository.findDescriptionById",
		fx.heavyTournamentId,
		(tournamentId) => TournamentRepository.findDescriptionById(tournamentId),
	);
	add(
		"TournamentRepository.findSeedingSnapshotById",
		fx.heavyTournamentId,
		(tournamentId) =>
			TournamentRepository.findSeedingSnapshotById(tournamentId),
	);
	add(
		"TournamentRepository.findResultsByTournamentId",
		fx.heavyResultsTournamentId,
		(tournamentId) =>
			TournamentRepository.findResultsByTournamentId(tournamentId),
	);
	addStatic("TournamentRepository.findLatestFinalizedLeagueParticipants", () =>
		TournamentRepository.findLatestFinalizedLeagueParticipants({
			organizationId: LUTI_ORGANIZATION_ID,
			namePrefix: LUTI_NAME_PREFIX,
		}),
	);
	add(
		"TournamentRepository.findTOSetMapPoolById",
		fx.heavyTournamentId,
		(tournamentId) => TournamentRepository.findTOSetMapPoolById(tournamentId),
	);
	add(
		"TournamentRepository.findPreparedMapsById",
		fx.heavyTournamentId,
		(tournamentId) => TournamentRepository.findPreparedMapsById(tournamentId),
	);
	add(
		"TournamentRepository.findRelatedUsersByTournamentIds",
		fx.recentTournamentIds,
		(tournamentIds) =>
			TournamentRepository.findRelatedUsersByTournamentIds(tournamentIds),
	);
	add(
		"TournamentRepository.findParticipantStreamAccounts",
		fx.recentTournamentIds,
		(tournamentIds) =>
			TournamentRepository.findParticipantStreamAccounts(tournamentIds),
	);
	addStatic("TournamentRepository.findAllForShowcase", () =>
		TournamentRepository.findAllForShowcase(),
	);
	add(
		"TournamentRepository.findShowcaseCountsById",
		fx.heavyTournamentId,
		(tournamentId) => TournamentRepository.findShowcaseCountsById(tournamentId),
	);
	add(
		"TournamentRepository.findAllBetweenTwoTimestamps",
		fx.calendarWindow,
		(window) => TournamentRepository.findAllBetweenTwoTimestamps(window),
	);
	add(
		"TournamentRepository.findPendingCheckInsStartingBetween",
		fx.calendarWindow,
		(window) =>
			TournamentRepository.findPendingCheckInsStartingBetween({
				startsAfter: window.startTime,
				startsBefore: window.endTime,
			}),
	);
	add(
		"TournamentRepository.findTopThreeResultsByTournamentIds",
		fx.heavyTournamentId,
		(tournamentId) =>
			TournamentRepository.findTopThreeResultsByTournamentIds([tournamentId]),
	);
	add(
		"TournamentRepository.findFriendCodesByTournamentId",
		fx.heavyTournamentId,
		(tournamentId) =>
			TournamentRepository.findFriendCodesByTournamentId(tournamentId),
	);
	add(
		"TournamentRepository.findPickBanEventsByMatchId",
		fx.heavyTournamentMatchId,
		(matchId) => TournamentRepository.findPickBanEventsByMatchId(matchId),
	);
	addStatic("TournamentRepository.searchByName", () =>
		TournamentRepository.searchByName(SEARCH_QUERY),
	);
	addStatic("TournamentRepository.findRunningTournamentIds", () =>
		TournamentRepository.findRunningTournamentIds(),
	);
	add(
		"TournamentRepository.findDivisionTiersByTournamentId",
		fx.heavyTournamentId,
		(tournamentId) =>
			TournamentRepository.findDivisionTiersByTournamentId(tournamentId),
	);

	add(
		"TournamentTeamRepository.findAllByChatRoomIds",
		fx.openChatRoomIdsByType?.TOURNAMENT_TEAM ?? null,
		(roomIds) => TournamentTeamRepository.findAllByChatRoomIds(roomIds),
	);
	add(
		"TournamentTeamRepository.findAllMembersByTeamIds",
		fx.manyTournamentTeamIds,
		(teamIds) => TournamentTeamRepository.findAllMembersByTeamIds(teamIds),
	);
	add(
		"TournamentTeamRepository.findByInviteCode",
		fx.tournamentTeamInviteCode,
		(inviteCode) => TournamentTeamRepository.findByInviteCode(inviteCode),
	);
	add(
		"TournamentTeamRepository.findInviteCodeById",
		fx.heavyTournamentTeamId,
		(tournamentTeamId) =>
			TournamentTeamRepository.findInviteCodeById(tournamentTeamId),
	);
	add(
		"TournamentTeamRepository.findAllChatRoomIdsByIds",
		fx.heavyTournamentTeamId,
		(tournamentTeamId) =>
			TournamentTeamRepository.findAllChatRoomIdsByIds([tournamentTeamId]),
	);
	add("TournamentTeamRepository.isPickupAvatarImgId", fx.imageId, (imageId) =>
		TournamentTeamRepository.isPickupAvatarImgId(imageId),
	);
	add(
		"TournamentTeamRepository.findRecentlyPlayedMapsByIds",
		both(fx.tournamentTeamPair, fx.heavyTournamentMatchId),
		([teamIds, excludeMatchId]) =>
			TournamentTeamRepository.findRecentlyPlayedMapsByIds({
				teamIds,
				excludeMatchId,
			}),
	);
	add(
		"TournamentTeamRepository.findMapPoolsByTeamIds",
		fx.tournamentTeamPair,
		(teamIds) => TournamentTeamRepository.findMapPoolsByTeamIds(teamIds),
	);
	add(
		"TournamentTeamRepository.findAllRegistrationsByUserIds",
		both(fx.manyUserIds, fx.availabilityWindow),
		([userIds, window]) =>
			TournamentTeamRepository.findAllRegistrationsByUserIds({
				userIds,
				startsAt: window.startsAt,
				endsAt: window.endsAt,
			}),
	);
	add(
		"TournamentTeamRepository.isOrganizerAddedMember",
		both(fx.heavyTournamentTeamId, fx.heavyUser),
		([tournamentTeamId, user]) =>
			TournamentTeamRepository.isOrganizerAddedMember({
				tournamentTeamId,
				userId: user.id,
			}),
	);

	addStatic("TrophyRepository.all", () => TrophyRepository.all());
	add("TrophyRepository.findById", fx.trophy, (trophy) =>
		TrophyRepository.findById(trophy.heavyTrophyId),
	);
	add("TrophyRepository.findByOwnerUserId", fx.trophy, (trophy) =>
		TrophyRepository.findByOwnerUserId(trophy.ownerUserId),
	);
	add("TrophyRepository.findTournamentsByTrophyId", fx.trophy, (trophy) =>
		TrophyRepository.findTournamentsByTrophyId(trophy.heavyTrophyId),
	);
	add("TrophyRepository.findWinsByOwner", fx.trophy, (trophy) =>
		TrophyRepository.findWinsByOwner(trophy.wins),
	);

	add("UserCardRepository.findAllByUserIds", fx.manyUserIds, (userIds) =>
		UserCardRepository.findAllByUserIds({
			userIds,
			include: { friendCode: true },
			includeHiddenStats: true,
		}),
	);
	add("UserCardRepository.findAllByUserIdsCached", fx.manyUserIds, (userIds) =>
		UserCardRepository.findAllByUserIdsCached({ userIds }),
	);
	add("UserCardRepository.findCardEditExtrasByUserId", fx.heavyUser, (user) =>
		UserCardRepository.findCardEditExtrasByUserId(user.id),
	);
	add("UserCardRepository.findVerifiedXpByUserId", fx.heavyUser, (user) =>
		UserCardRepository.findVerifiedXpByUserId(user.id, null),
	);

	add("UserRepository.findIdByIdentifier", fx.heavyUser, (user) =>
		UserRepository.findIdByIdentifier(user.identifier),
	);
	add("UserRepository.findPageUserByIdentifier", fx.heavyUser, (user) =>
		UserRepository.findPageUserByIdentifier(user.identifier),
	);
	add("UserRepository.findCountriesByUserIds", fx.skillBatch, (skillBatch) =>
		UserRepository.findCountriesByUserIds(skillBatch.userIds),
	);
	add("UserRepository.findPlusTiersByUserIds", fx.skillBatch, (skillBatch) =>
		UserRepository.findPlusTiersByUserIds(skillBatch.userIds),
	);
	add("UserRepository.findBuildFieldsByUserId", fx.heavyUser, (user) =>
		UserRepository.findBuildFieldsByUserId(user.id),
	);
	add("UserRepository.findLayoutDataById", fx.heavyUser, (user) =>
		UserRepository.findLayoutDataById(user.id, user.id),
	);
	add("UserRepository.findProfileByUserId", fx.heavyUser, (user) =>
		UserRepository.findProfileByUserId(user.id),
	);
	add("UserRepository.findStoredWidgetsByUserId", fx.heavyUser, (user) =>
		UserRepository.findStoredWidgetsByUserId(user.id),
	);
	add("UserRepository.findWidgetsByUserId", fx.heavyUser, (user) =>
		UserRepository.findWidgetsByUserId(user.id),
	);
	add("UserRepository.findByCustomUrl", fx.userCustomUrl, (customUrl) =>
		UserRepository.findByCustomUrl(customUrl),
	);
	add("UserRepository.findByFriendCode", fx.friendCode, (friendCode) =>
		UserRepository.findByFriendCode(friendCode),
	);
	add("UserRepository.findLeanById", fx.heavyUser, (user) =>
		UserRepository.findLeanById(user.id),
	);
	add("UserRepository.findModInfoById", fx.heavyUser, (user) =>
		UserRepository.findModInfoById(user.id),
	);
	addStatic("UserRepository.findAllPatrons", () =>
		UserRepository.findAllPatrons(),
	);
	addStatic("UserRepository.findAllPlusServerMembers", () =>
		UserRepository.findAllPlusServerMembers(),
	);
	add("UserRepository.findResultsByUserId", fx.heavyUser, (user) =>
		UserRepository.findResultsByUserId(user.id, {}),
	);
	add("UserRepository.findResultsByUserId.page", fx.heavyUser, (user) =>
		UserRepository.findResultsByUserId(user.id, { limit: 25, offset: 25 }),
	);
	add("UserRepository.findResultsByUserId.widget", fx.heavyUser, (user) =>
		UserRepository.findResultsByUserId(user.id, { limit: 3 }),
	);
	add("UserRepository.countResultsByUserId", fx.heavyUser, (user) =>
		UserRepository.countResultsByUserId(user.id),
	);
	add("UserRepository.hasHighlightedResultsByUserId", fx.heavyUser, (user) =>
		UserRepository.hasHighlightedResultsByUserId(user.id),
	);
	add("UserRepository.findResultPlacementsByUserId", fx.heavyUser, (user) =>
		UserRepository.findResultPlacementsByUserId(user.id),
	);
	addStatic("UserRepository.search", () => UserRepository.search(SEARCH_QUERY));
	add("UserRepository.searchExact", fx.userCustomUrl, (customUrl) =>
		UserRepository.searchExact({ customUrl }),
	);
	add("UserRepository.findCurrentFriendCodeByUserId", fx.heavyUser, (user) =>
		UserRepository.findCurrentFriendCodeByUserId(user.id),
	);
	add("UserRepository.findFriendCodesByUserId", fx.heavyUser, (user) =>
		UserRepository.findFriendCodesByUserId(user.id),
	);
	addStatic("UserRepository.findAllCurrentFriendCodes", () =>
		UserRepository.findAllCurrentFriendCodes(),
	);
	add("UserRepository.findInGameNameByUserId", fx.heavyUser, (user) =>
		UserRepository.findInGameNameByUserId(user.id),
	);
	add("UserRepository.findPatronStartedAtByUserId", fx.heavyUser, (user) =>
		UserRepository.findPatronStartedAtByUserId(user.id),
	);
	add("UserRepository.findDivByUserId", fx.heavyUser, (user) =>
		UserRepository.findDivByUserId(user.id),
	);
	add("UserRepository.findJoinOrderByUserId", fx.heavyUser, (user) =>
		UserRepository.findJoinOrderByUserId(user.id),
	);
	add("UserRepository.findCommissionsByUserId", fx.heavyUser, (user) =>
		UserRepository.findCommissionsByUserId(user.id),
	);
	add("UserRepository.anyUserPrefersNoScreen", fx.manyUserIds, (userIds) =>
		UserRepository.anyUserPrefersNoScreen(userIds),
	);
	add("UserRepository.findSocialLinksByUserId", fx.heavyUser, (user) =>
		UserRepository.findSocialLinksByUserId(user.id),
	);
	add(
		"UserRepository.findIdsByStreamAccounts",
		fx.streamAccounts,
		(streamAccounts) => UserRepository.findIdsByStreamAccounts(streamAccounts),
	);

	add("VodRepository.findByUserId", fx.vod, (vod) =>
		VodRepository.findByUserId(vod.userId),
	);
	addStatic("VodRepository.findVods.default", () => VodRepository.findVods({}));
	add("VodRepository.findVods.byWeapon", fx.heavyWeaponSplId, (weaponSplId) =>
		VodRepository.findVods({ weapon: weaponSplId }),
	);
	addStatic("VodRepository.countVods", () => VodRepository.countVods({}));
	add("VodRepository.findVodById", fx.vod, (vod) =>
		VodRepository.findVodById(vod.videoId),
	);

	return { cases, skipped };
}

function both<A, B>(a: A | null, b: B | null): [A, B] | null {
	if (a === null || b === null) return null;

	return [a, b];
}

function categoryWeaponIds(weaponSplId: MainWeaponId) {
	const category = weaponIdToCategory(weaponSplId);

	return [...weaponCategories.find(({ name }) => name === category)!.weaponIds];
}