style: format code biome

src/app/api/badges/leaderboard/route.ts

@@ -2,58 +2,72 @@ import { Prisma } from "@/generated/prisma/client";
 import { apiJson } from "@/lib/api";
 import { bearerUserId } from "@/lib/api-auth";
 import { auth } from "@/lib/auth";
-import { prisma } from "@/lib/prisma";
 import { logger } from "@/lib/logger";
+import { prisma } from "@/lib/prisma";
 
 export const dynamic = "force-dynamic";
 
-type BadgeRarityKey = "common" | "rare" | "epic" | "legendary" | "mythical" | "unique";
+type BadgeRarityKey =
+	| "common"
+	| "rare"
+	| "epic"
+	| "legendary"
+	| "mythical"
+	| "unique";
 
 interface BadgeLeaderboardEntry {
-  userId: number;
-  username: string;
-  figure: string;
-  score: number;
-  rank: number;
+	userId: number;
+	username: string;
+	figure: string;
+	score: number;
+	rank: number;
 }
 
 interface BadgeLeaderboardBoard {
-  entries: BadgeLeaderboardEntry[];
-  totalPlayers: number;
-  viewerEntry?: Partial<BadgeLeaderboardEntry>;
+	entries: BadgeLeaderboardEntry[];
+	totalPlayers: number;
+	viewerEntry?: Partial<BadgeLeaderboardEntry>;
 }
 
 interface BadgeLeaderboardStat {
-  badgeCode: string;
-  ownerCount: number;
-  rarity: BadgeRarityKey;
+	badgeCode: string;
+	ownerCount: number;
+	rarity: BadgeRarityKey;
 }
 
 const THRESHOLDS = {
-  commonMinOwners: 500,
-  rareMinOwners: 100,
-  epicMinOwners: 20,
-  legendaryMinOwners: 5,
-  mythicalMinOwners: 2,
-  uniqueOwners: 1,
+	commonMinOwners: 500,
+	rareMinOwners: 100,
+	epicMinOwners: 20,
+	legendaryMinOwners: 5,
+	mythicalMinOwners: 2,
+	uniqueOwners: 1,
 };
 
 function assignRarity(ownerCount: number): BadgeRarityKey {
-  if (ownerCount >= THRESHOLDS.commonMinOwners) return "common";
-  if (ownerCount >= THRESHOLDS.rareMinOwners) return "rare";
-  if (ownerCount >= THRESHOLDS.epicMinOwners) return "epic";
-  if (ownerCount >= THRESHOLDS.legendaryMinOwners) return "legendary";
-  if (ownerCount >= THRESHOLDS.mythicalMinOwners) return "mythical";
-  return "unique";
+	if (ownerCount >= THRESHOLDS.commonMinOwners) return "common";
+	if (ownerCount >= THRESHOLDS.rareMinOwners) return "rare";
+	if (ownerCount >= THRESHOLDS.epicMinOwners) return "epic";
+	if (ownerCount >= THRESHOLDS.legendaryMinOwners) return "legendary";
+	if (ownerCount >= THRESHOLDS.mythicalMinOwners) return "mythical";
+	return "unique";
 }
 
-function rankEntries(entries: BadgeLeaderboardEntry[]): BadgeLeaderboardEntry[] {
-  return entries.sort((a, b) => b.score - a.score).map((e, i) => ({ ...e, rank: i + 1 }));
+function rankEntries(
+	entries: BadgeLeaderboardEntry[],
+): BadgeLeaderboardEntry[] {
+	return entries
+		.sort((a, b) => b.score - a.score)
+		.map((e, i) => ({ ...e, rank: i + 1 }));
 }
 
-async function loadTotalBadgesBoard(userId: number | null): Promise<BadgeLeaderboardBoard> {
-  const rows = await prisma.$queryRaw<Array<{ userId: bigint; username: string; look: string; cnt: bigint }>>(
-    Prisma.sql`
+async function loadTotalBadgesBoard(
+	userId: number | null,
+): Promise<BadgeLeaderboardBoard> {
+	const rows = await prisma.$queryRaw<
+		Array<{ userId: bigint; username: string; look: string; cnt: bigint }>
+	>(
+		Prisma.sql`
       SELECT ub.user_id AS userId, u.username, u.look, COUNT(*) AS cnt
       FROM users_badges ub
       JOIN users u ON u.id = ub.user_id
@@ -61,149 +75,153 @@ async function loadTotalBadgesBoard(userId: number | null): Promise<BadgeLeaderb
       ORDER BY cnt DESC
       LIMIT 20
     `,
-  );
+	);
 
-  const entries = rankEntries(
-    rows.map((r) => ({
-      userId: Number(r.userId),
-      username: r.username,
-      figure: r.look,
-      score: Number(r.cnt),
-      rank: 0,
-    })),
-  );
+	const entries = rankEntries(
+		rows.map((r) => ({
+			userId: Number(r.userId),
+			username: r.username,
+			figure: r.look,
+			score: Number(r.cnt),
+			rank: 0,
+		})),
+	);
 
-  const totalPlayers =
-    entries.length > 0
-      ? Number(
-          (
-            await prisma.$queryRaw<Array<{ cnt: bigint }>>(
-              Prisma.sql`SELECT COUNT(DISTINCT user_id) AS cnt FROM users_badges`,
-            )
-          )[0]?.cnt ?? 0,
-        )
-      : 0;
+	const totalPlayers =
+		entries.length > 0
+			? Number(
+					(
+						await prisma.$queryRaw<Array<{ cnt: bigint }>>(
+							Prisma.sql`SELECT COUNT(DISTINCT user_id) AS cnt FROM users_badges`,
+						)
+					)[0]?.cnt ?? 0,
+				)
+			: 0;
 
-  let viewerEntry: Partial<BadgeLeaderboardEntry> | undefined;
-  if (userId) {
-    const viewerRow = await prisma.$queryRaw<Array<{ cnt: bigint }>>(
-      Prisma.sql`SELECT COUNT(*) AS cnt FROM users_badges WHERE user_id = ${userId}`,
-    );
-    const viewerScore = Number(viewerRow[0]?.cnt ?? 0);
-    if (viewerScore > 0) {
-      const viewerRank =
-        entries.length > 0
-          ? Number(
-              (
-                await prisma.$queryRaw<Array<{ cnt: bigint }>>(
-                  Prisma.sql`
+	let viewerEntry: Partial<BadgeLeaderboardEntry> | undefined;
+	if (userId) {
+		const viewerRow = await prisma.$queryRaw<Array<{ cnt: bigint }>>(
+			Prisma.sql`SELECT COUNT(*) AS cnt FROM users_badges WHERE user_id = ${userId}`,
+		);
+		const viewerScore = Number(viewerRow[0]?.cnt ?? 0);
+		if (viewerScore > 0) {
+			const viewerRank =
+				entries.length > 0
+					? Number(
+							(
+								await prisma.$queryRaw<Array<{ cnt: bigint }>>(
+									Prisma.sql`
                     SELECT COUNT(*) + 1 AS cnt
                     FROM (SELECT user_id, COUNT(*) AS total FROM users_badges GROUP BY user_id) t
                     WHERE t.total > ${viewerScore}
                   `,
-                )
-              )[0]?.cnt ?? entries.length + 1,
-            )
-          : 1;
-      const viewerUser = await prisma.user.findUnique({
-        where: { id: userId },
-        select: { username: true, look: true },
-      });
-      if (viewerUser) {
-        viewerEntry = {
-          userId,
-          username: viewerUser.username,
-          figure: viewerUser.look,
-          score: viewerScore,
-          rank: viewerRank,
-        };
-      }
-    }
-  }
+								)
+							)[0]?.cnt ?? entries.length + 1,
+						)
+					: 1;
+			const viewerUser = await prisma.user.findUnique({
+				where: { id: userId },
+				select: { username: true, look: true },
+			});
+			if (viewerUser) {
+				viewerEntry = {
+					userId,
+					username: viewerUser.username,
+					figure: viewerUser.look,
+					score: viewerScore,
+					rank: viewerRank,
+				};
+			}
+		}
+	}
 
-  return { entries, totalPlayers, viewerEntry };
+	return { entries, totalPlayers, viewerEntry };
 }
 
-async function loadAchievementBoard(userId: number | null): Promise<BadgeLeaderboardBoard> {
-  const rows = await prisma.$queryRaw<
-    Array<{ userId: bigint; username: string; look: string; score: number }>
-  >(
-    Prisma.sql`
+async function loadAchievementBoard(
+	userId: number | null,
+): Promise<BadgeLeaderboardBoard> {
+	const rows = await prisma.$queryRaw<
+		Array<{ userId: bigint; username: string; look: string; score: number }>
+	>(
+		Prisma.sql`
       SELECT us.user_id AS userId, u.username, u.look, us.achievement_score AS score
       FROM users_settings us
       JOIN users u ON u.id = us.user_id
       ORDER BY us.achievement_score DESC
       LIMIT 20
     `,
-  );
+	);
 
-  const entries = rankEntries(
-    rows.map((r) => ({
-      userId: Number(r.userId),
-      username: r.username,
-      figure: r.look,
-      score: r.score,
-      rank: 0,
-    })),
-  );
+	const entries = rankEntries(
+		rows.map((r) => ({
+			userId: Number(r.userId),
+			username: r.username,
+			figure: r.look,
+			score: r.score,
+			rank: 0,
+		})),
+	);
 
-  const totalPlayers =
-    entries.length > 0
-      ? Number(
-          (
-            await prisma.$queryRaw<Array<{ cnt: bigint }>>(
-              Prisma.sql`SELECT COUNT(*) AS cnt FROM users_settings WHERE achievement_score > 0`,
-            )
-          )[0]?.cnt ?? 0,
-        )
-      : 0;
+	const totalPlayers =
+		entries.length > 0
+			? Number(
+					(
+						await prisma.$queryRaw<Array<{ cnt: bigint }>>(
+							Prisma.sql`SELECT COUNT(*) AS cnt FROM users_settings WHERE achievement_score > 0`,
+						)
+					)[0]?.cnt ?? 0,
+				)
+			: 0;
 
-  let viewerEntry: Partial<BadgeLeaderboardEntry> | undefined;
-  if (userId) {
-    const viewerUser = await prisma.user.findUnique({
-      where: { id: userId },
-      select: { username: true, look: true },
-    });
-    if (viewerUser) {
-      const viewerSettings = await prisma.usersSettings.findUnique({
-        where: { userId },
-        select: { achievementScore: true },
-      });
-      if (viewerSettings && viewerSettings.achievementScore > 0) {
-        const viewerRank = Number(
-          (
-            await prisma.$queryRaw<Array<{ cnt: bigint }>>(
-              Prisma.sql`
+	let viewerEntry: Partial<BadgeLeaderboardEntry> | undefined;
+	if (userId) {
+		const viewerUser = await prisma.user.findUnique({
+			where: { id: userId },
+			select: { username: true, look: true },
+		});
+		if (viewerUser) {
+			const viewerSettings = await prisma.usersSettings.findUnique({
+				where: { userId },
+				select: { achievementScore: true },
+			});
+			if (viewerSettings && viewerSettings.achievementScore > 0) {
+				const viewerRank = Number(
+					(
+						await prisma.$queryRaw<Array<{ cnt: bigint }>>(
+							Prisma.sql`
                 SELECT COUNT(*) + 1 AS cnt FROM users_settings WHERE achievement_score > ${viewerSettings.achievementScore}
               `,
-            )
-          )[0]?.cnt ?? entries.length + 1,
-        );
-        viewerEntry = {
-          userId,
-          username: viewerUser.username,
-          figure: viewerUser.look,
-          score: viewerSettings.achievementScore,
-          rank: viewerRank,
-        };
-      }
-    }
-  }
+						)
+					)[0]?.cnt ?? entries.length + 1,
+				);
+				viewerEntry = {
+					userId,
+					username: viewerUser.username,
+					figure: viewerUser.look,
+					score: viewerSettings.achievementScore,
+					rank: viewerRank,
+				};
+			}
+		}
+	}
 
-  return { entries, totalPlayers, viewerEntry };
+	return { entries, totalPlayers, viewerEntry };
 }
 
 async function loadRarityBoard(
-  rarity: BadgeRarityKey,
-  badgeCodes: string[],
-  userId: number | null,
+	_rarity: BadgeRarityKey,
+	badgeCodes: string[],
+	userId: number | null,
 ): Promise<BadgeLeaderboardBoard> {
-  if (badgeCodes.length === 0) return { entries: [], totalPlayers: 0 };
+	if (badgeCodes.length === 0) return { entries: [], totalPlayers: 0 };
 
-  const codes = Prisma.join(badgeCodes);
+	const codes = Prisma.join(badgeCodes);
 
-  const rows = await prisma.$queryRaw<Array<{ userId: bigint; username: string; look: string; cnt: bigint }>>(
-    Prisma.sql`
+	const rows = await prisma.$queryRaw<
+		Array<{ userId: bigint; username: string; look: string; cnt: bigint }>
+	>(
+		Prisma.sql`
       SELECT ub.user_id AS userId, u.username, u.look, COUNT(*) AS cnt
       FROM users_badges ub
       JOIN users u ON u.id = ub.user_id
@@ -212,137 +230,151 @@ async function loadRarityBoard(
       ORDER BY cnt DESC
       LIMIT 20
     `,
-  );
+	);
 
-  const entries = rankEntries(
-    rows.map((r) => ({
-      userId: Number(r.userId),
-      username: r.username,
-      figure: r.look,
-      score: Number(r.cnt),
-      rank: 0,
-    })),
-  );
+	const entries = rankEntries(
+		rows.map((r) => ({
+			userId: Number(r.userId),
+			username: r.username,
+			figure: r.look,
+			score: Number(r.cnt),
+			rank: 0,
+		})),
+	);
 
-  const totalPlayers =
-    rows.length > 0
-      ? Number(
-          (
-            await prisma.$queryRaw<Array<{ cnt: bigint }>>(
-              Prisma.sql`
+	const totalPlayers =
+		rows.length > 0
+			? Number(
+					(
+						await prisma.$queryRaw<Array<{ cnt: bigint }>>(
+							Prisma.sql`
                 SELECT COUNT(DISTINCT user_id) AS cnt FROM users_badges WHERE badge_code IN (${codes})
               `,
-            )
-          )[0]?.cnt ?? 0,
-        )
-      : 0;
+						)
+					)[0]?.cnt ?? 0,
+				)
+			: 0;
 
-  let viewerEntry: Partial<BadgeLeaderboardEntry> | undefined;
-  if (userId) {
-    const viewerRow = await prisma.$queryRaw<Array<{ cnt: bigint }>>(
-      Prisma.sql`
+	let viewerEntry: Partial<BadgeLeaderboardEntry> | undefined;
+	if (userId) {
+		const viewerRow = await prisma.$queryRaw<Array<{ cnt: bigint }>>(
+			Prisma.sql`
         SELECT COUNT(*) AS cnt FROM users_badges
         WHERE user_id = ${userId} AND badge_code IN (${codes})
       `,
-    );
-    const viewerScore = Number(viewerRow[0]?.cnt ?? 0);
-    if (viewerScore > 0) {
-      const viewerUser = await prisma.user.findUnique({
-        where: { id: userId },
-        select: { username: true, look: true },
-      });
-      if (viewerUser) {
-        const viewerRank = Number(
-          (
-            await prisma.$queryRaw<Array<{ cnt: bigint }>>(
-              Prisma.sql`
+		);
+		const viewerScore = Number(viewerRow[0]?.cnt ?? 0);
+		if (viewerScore > 0) {
+			const viewerUser = await prisma.user.findUnique({
+				where: { id: userId },
+				select: { username: true, look: true },
+			});
+			if (viewerUser) {
+				const viewerRank = Number(
+					(
+						await prisma.$queryRaw<Array<{ cnt: bigint }>>(
+							Prisma.sql`
                 SELECT COUNT(*) + 1 AS cnt
                 FROM (SELECT user_id, COUNT(*) AS total FROM users_badges WHERE badge_code IN (${codes}) GROUP BY user_id) t
                 WHERE t.total > ${viewerScore}
               `,
-            )
-          )[0]?.cnt ?? entries.length + 1,
-        );
-        viewerEntry = {
-          userId,
-          username: viewerUser.username,
-          figure: viewerUser.look,
-          score: viewerScore,
-          rank: viewerRank,
-        };
-      }
-    }
-  }
+						)
+					)[0]?.cnt ?? entries.length + 1,
+				);
+				viewerEntry = {
+					userId,
+					username: viewerUser.username,
+					figure: viewerUser.look,
+					score: viewerScore,
+					rank: viewerRank,
+				};
+			}
+		}
+	}
 
-  return { entries, totalPlayers, viewerEntry };
+	return { entries, totalPlayers, viewerEntry };
 }
 
 export async function GET(req: Request) {
-  try {
-    let userId: number | null = await bearerUserId(req);
-    if (!userId) {
-      const session = await auth();
-      userId = session?.user?.id ? Number(session.user.id) : null;
-    }
+	try {
+		let userId: number | null = await bearerUserId(req);
+		if (!userId) {
+			const session = await auth();
+			userId = session?.user?.id ? Number(session.user.id) : null;
+		}
 
-    const badgeStatsRaw = await prisma.$queryRaw<Array<{ badgeCode: string; ownerCount: bigint }>>(
-      Prisma.sql`
+		const badgeStatsRaw = await prisma.$queryRaw<
+			Array<{ badgeCode: string; ownerCount: bigint }>
+		>(
+			Prisma.sql`
         SELECT badge_code AS badgeCode, COUNT(DISTINCT user_id) AS ownerCount
         FROM users_badges
         GROUP BY badge_code
       `,
-    );
+		);
 
-    const badgeStats: BadgeLeaderboardStat[] = badgeStatsRaw.map((r) => ({
-      badgeCode: r.badgeCode,
-      ownerCount: Number(r.ownerCount),
-      rarity: assignRarity(Number(r.ownerCount)),
-    }));
+		const badgeStats: BadgeLeaderboardStat[] = badgeStatsRaw.map((r) => ({
+			badgeCode: r.badgeCode,
+			ownerCount: Number(r.ownerCount),
+			rarity: assignRarity(Number(r.ownerCount)),
+		}));
 
-    const badgesByRarity = new Map<BadgeRarityKey, string[]>();
-    for (const stat of badgeStats) {
-      const list = badgesByRarity.get(stat.rarity) ?? [];
-      list.push(stat.badgeCode);
-      badgesByRarity.set(stat.rarity, list);
-    }
+		const badgesByRarity = new Map<BadgeRarityKey, string[]>();
+		for (const stat of badgeStats) {
+			const list = badgesByRarity.get(stat.rarity) ?? [];
+			list.push(stat.badgeCode);
+			badgesByRarity.set(stat.rarity, list);
+		}
 
-    const rarityKeys: BadgeRarityKey[] = ["common", "rare", "epic", "legendary", "mythical", "unique"];
+		const rarityKeys: BadgeRarityKey[] = [
+			"common",
+			"rare",
+			"epic",
+			"legendary",
+			"mythical",
+			"unique",
+		];
 
-    const [totalBadges, achievementLevel, ...rarityBoards] = await Promise.all([
-      loadTotalBadgesBoard(userId),
-      loadAchievementBoard(userId),
-      ...rarityKeys.map((rk) => loadRarityBoard(rk, badgesByRarity.get(rk) ?? [], userId)),
-    ]);
+		const [totalBadges, achievementLevel, ...rarityBoards] = await Promise.all([
+			loadTotalBadgesBoard(userId),
+			loadAchievementBoard(userId),
+			...rarityKeys.map((rk) =>
+				loadRarityBoard(rk, badgesByRarity.get(rk) ?? [], userId),
+			),
+		]);
 
-    const rarity = Object.fromEntries(
-      // eslint-disable-next-line security/detect-object-injection -- rk from rarityKeys const, i is array index
-      rarityKeys.map((rk, i) => [rk, rarityBoards[i]]),
-    ) as Record<BadgeRarityKey, BadgeLeaderboardBoard>;
+		const rarity = Object.fromEntries(
+			// eslint-disable-next-line security/detect-object-injection -- rk from rarityKeys const, i is array index
+			rarityKeys.map((rk, i) => [rk, rarityBoards[i]]),
+		) as Record<BadgeRarityKey, BadgeLeaderboardBoard>;
 
-    return apiJson({
-      viewerUserId: userId ?? 0,
-      badgeStats,
-      thresholds: THRESHOLDS,
-      leaderboards: { totalBadges, achievementLevel, rarity },
-    });
-  } catch (err) {
-    logger.error("Badge leaderboard error", { module: "badges/leaderboard", error: String(err) });
-    return apiJson({
-      viewerUserId: 0,
-      badgeStats: [],
-      thresholds: THRESHOLDS,
-      leaderboards: {
-        totalBadges: { entries: [], totalPlayers: 0 },
-        achievementLevel: { entries: [], totalPlayers: 0 },
-        rarity: {
-          common: { entries: [], totalPlayers: 0 },
-          rare: { entries: [], totalPlayers: 0 },
-          epic: { entries: [], totalPlayers: 0 },
-          legendary: { entries: [], totalPlayers: 0 },
-          mythical: { entries: [], totalPlayers: 0 },
-          unique: { entries: [], totalPlayers: 0 },
-        },
-      },
-    });
-  }
+		return apiJson({
+			viewerUserId: userId ?? 0,
+			badgeStats,
+			thresholds: THRESHOLDS,
+			leaderboards: { totalBadges, achievementLevel, rarity },
+		});
+	} catch (err) {
+		logger.error("Badge leaderboard error", {
+			module: "badges/leaderboard",
+			error: String(err),
+		});
+		return apiJson({
+			viewerUserId: 0,
+			badgeStats: [],
+			thresholds: THRESHOLDS,
+			leaderboards: {
+				totalBadges: { entries: [], totalPlayers: 0 },
+				achievementLevel: { entries: [], totalPlayers: 0 },
+				rarity: {
+					common: { entries: [], totalPlayers: 0 },
+					rare: { entries: [], totalPlayers: 0 },
+					epic: { entries: [], totalPlayers: 0 },
+					legendary: { entries: [], totalPlayers: 0 },
+					mythical: { entries: [], totalPlayers: 0 },
+					unique: { entries: [], totalPlayers: 0 },
+				},
+			},
+		});
+	}
 }