rhythia-api 217.0.0 → 226.0.0

package/api/getBeatmapPageById.ts

@@ -1,19 +1,20 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi } from "../utils/requestUtils";
-import { getCacheValue, setCacheValue } from "../utils/cache";
-import { supabase } from "../utils/supabase";
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi } from "../utils/requestUtils";
+import { getCacheValue, setCacheValue } from "../utils/cache";
+import { supabase } from "../utils/supabase";
+import { getActiveProfileIdSet } from "../utils/activityStatus";
 
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    mapId: z.string(),
-    limit: z.number().min(1).max(200).default(50),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-    scores: z
-      .array(
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    mapId: z.string(),
+    limit: z.number().min(1).max(200).default(50),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    scores: z
+      .array(
         z.object({
           id: z.number(),
           awarded_sp: z.number().nullable(),
@@ -64,14 +65,14 @@ export async function POST(request: Request): Promise<NextResponse> {
   });
 }
 
-export async function handler(
-  data: (typeof Schema)["input"]["_type"],
-  req: Request
-): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
-  const limit = data.limit ?? 50;
-
-  let { data: beatmapPage, error: errorlast } = await supabase
-    .from("beatmapPages")
+export async function handler(
+  data: (typeof Schema)["input"]["_type"],
+  req: Request
+): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  const limit = data.limit ?? 50;
+
+  let { data: beatmapPage, error: errorlast } = await supabase
+    .from("beatmapPages")
     .select(
       `
       *,
@@ -93,46 +94,54 @@ export async function handler(
       )
     `
     )
-    .eq("latestBeatmapHash", data.mapId)
-    .single();
-
-  if (!beatmapPage) return NextResponse.json({});
-
-  const beatmapHash = beatmapPage?.latestBeatmapHash || "";
-  const isCacheable =
-    beatmapPage?.status === "RANKED" || beatmapPage?.status === "APPROVED";
-  const cacheKey = `beatmap-scores:${beatmapHash}:limit=${limit}`;
-
-  let scoreData: any[] | null = null;
-
-  if (isCacheable && beatmapHash) {
-    scoreData = await getCacheValue<any[]>(cacheKey);
-  }
-
-  if (!scoreData) {
-    const { data: rpcScores, error } = await supabase.rpc(
-      "get_top_scores_for_beatmap",
-      { beatmap_hash: beatmapHash }
-    );
-
-    if (error) {
-      return NextResponse.json({ error: JSON.stringify(error) });
-    }
-
-    scoreData = (rpcScores || []).slice(0, limit);
-
-    if (isCacheable && beatmapHash) {
-      await setCacheValue(cacheKey, scoreData);
-    }
-  }
-
-  return NextResponse.json({
-    scores: (scoreData || []).map((score: any) => ({
-      id: score.id,
-      awarded_sp: score.awarded_sp,
-      created_at: score.created_at,
-      misses: score.misses,
-      mods: score.mods,
+    .eq("latestBeatmapHash", data.mapId)
+    .single();
+
+  if (!beatmapPage) return NextResponse.json({});
+
+  const beatmapHash = beatmapPage?.latestBeatmapHash || "";
+  const isCacheable =
+    beatmapPage?.status === "RANKED" || beatmapPage?.status === "APPROVED";
+  const cacheKey = `beatmap-scores:${beatmapHash}`;
+
+  let scoreData: any[] | null = null;
+
+  if (isCacheable && beatmapHash) {
+    scoreData = await getCacheValue<any[]>(cacheKey);
+  }
+
+  if (!scoreData) {
+    const { data: rpcScores, error } = await supabase.rpc(
+      "get_top_scores_for_beatmap",
+      { beatmap_hash: beatmapHash }
+    );
+
+    if (error) {
+      return NextResponse.json({ error: JSON.stringify(error) });
+    }
+
+    scoreData = (rpcScores || []).slice(0, 200);
+
+    if (isCacheable && beatmapHash) {
+      await setCacheValue(cacheKey, scoreData);
+    }
+  }
+
+  const userIds = Array.from(
+    new Set((scoreData || []).map((score) => score.userid).filter(Boolean))
+  );
+  const activeUserIds = await getActiveProfileIdSet(userIds);
+  const visibleScores = (scoreData || [])
+    .filter((score) => activeUserIds.has(score.userid))
+    .slice(0, limit);
+
+  return NextResponse.json({
+    scores: visibleScores.map((score: any) => ({
+      id: score.id,
+      awarded_sp: score.awarded_sp,
+      created_at: score.created_at,
+      misses: score.misses,
+      mods: score.mods,
       passed: score.passed,
       songId: score.songid,
       speed: score.speed,

package/api/getLeaderboard.ts

@@ -4,6 +4,9 @@ import { protectedApi } from "../utils/requestUtils";
 import { supabase } from "../utils/supabase";
 import { getUserBySession } from "../utils/getUserBySession";
 import { User } from "@supabase/supabase-js";
+import { getScoreActivityCutoffIso } from "../utils/activityStatus";
+import { getCacheValue, setCacheValue } from "../utils/cache";
+import { LEADERBOARD_CACHE_INVALIDATE_KEY } from "../utils/leaderboardCache";
 
 export const Schema = {
   input: z.strictObject({
@@ -11,6 +14,7 @@ export const Schema = {
     page: z.number().default(1),
     flag: z.string().optional(),
     spin: z.boolean().default(false),
+    include_inactive: z.boolean().optional().default(false),
   }),
   output: z.object({
     error: z.string().optional(),
@@ -23,6 +27,7 @@ export const Schema = {
         z.object({
           flag: z.string().nullable(),
           id: z.number(),
+          avatar_url: z.string().nullable(),
           username: z.string().nullable(),
           play_count: z.number().nullable(),
           skill_points: z.number().nullable(),
@@ -58,74 +63,112 @@ export async function handler(
     data.page,
     data.session,
     data.spin,
-    data.flag
+    data.flag,
+    data.include_inactive
   );
   return NextResponse.json(result);
 }
 
 const VIEW_PER_PAGE = 50;
+const CACHE_TTL_MS = 4 * 60 * 1000;
 
 export async function getLeaderboard(
   page = 1,
   session: string,
   spin: boolean,
-  flag?: string
+  flag?: string,
+  includeInactive = false
 ) {
-  const getUserData = (await getUserBySession(session)) as User;
+  const cutoffIso = getScoreActivityCutoffIso();
+  const userPromise = getUserBySession(session) as Promise<User | null>;
+  const invalidateAtPromise = getCacheValue<number>(
+    LEADERBOARD_CACHE_INVALIDATE_KEY
+  );
 
-  let leaderPosition = 0;
+  const startPage = (page - 1) * VIEW_PER_PAGE;
+  const endPage = startPage + VIEW_PER_PAGE - 1;
+  const cacheKey = `leaderboard:page=${page}:spin=${spin ? 1 : 0}:flag=${
+    flag || "all"
+  }:include_inactive=${includeInactive ? 1 : 0}`;
+  const cachedPagePromise = getCacheValue<{
+    cachedAt: number;
+    total: number;
+    leaderboard: (typeof Schema)["output"]["_type"]["leaderboard"];
+  }>(cacheKey);
 
-  if (getUserData) {
-    let { data: queryData, error } = await supabase
-      .from("profiles")
-      .select("*")
-      .eq("uid", getUserData.id)
-      .single();
+  const [user, invalidateAt, cachedPage] = await Promise.all([
+    userPromise,
+    invalidateAtPromise,
+    cachedPagePromise,
+  ]);
 
-    if (queryData) {
-      const { count: playersWithMorePoints, error: rankError } = await supabase
+  const cutoffInvalidation = invalidateAt || 0;
+  const now = Date.now();
+  const cacheFresh = Boolean(
+    cachedPage &&
+      cachedPage.cachedAt >= cutoffInvalidation &&
+      now - cachedPage.cachedAt < CACHE_TTL_MS
+  );
+
+  const pageDataPromise = (async () => {
+    if (cachedPage && cacheFresh) {
+      return cachedPage;
+    }
+
+    let countQuery;
+    let query;
+
+    if (includeInactive) {
+      countQuery = supabase
+        .from("profiles")
+        .select("id", { count: "exact", head: true })
+        .neq("ban", "excluded");
+
+      query = supabase
+        .from("profiles")
+        .select(
+          "flag,id,avatar_url,username,play_count,skill_points,spin_skill_points,total_score,verified,clans:clan(id, acronym)"
+        )
+        .neq("ban", "excluded");
+    } else {
+      countQuery = supabase
         .from("profiles")
-        .select("*", { count: "exact", head: true })
+        .select("id,scores!inner(id)", { count: "exact", head: true })
         .neq("ban", "excluded")
-        .gt("skill_points", queryData.skill_points);
+        .gte("scores.created_at", cutoffIso);
 
-      leaderPosition = (playersWithMorePoints || 0) + 1;
+      query = supabase
+        .from("profiles")
+        .select(
+          "flag,id,avatar_url,username,play_count,skill_points,spin_skill_points,total_score,verified,clans:clan(id, acronym),scores!inner(id)"
+        )
+        .neq("ban", "excluded")
+        .gte("scores.created_at", cutoffIso)
+        .limit(1, { foreignTable: "scores" });
     }
-  }
-
-  const startPage = (page - 1) * VIEW_PER_PAGE;
-  const endPage = startPage + VIEW_PER_PAGE - 1;
-  const countQuery = await supabase
-    .from("profiles")
-    .select("ban", { count: "exact", head: true })
-    .neq("ban", "excluded");
 
-  let query = supabase
-    .from("profiles")
-    .select("*,clans:clan(id, acronym)")
-    .neq("ban", "excluded");
+    if (flag) {
+      countQuery.eq("flag", flag);
+      query.eq("flag", flag);
+    }
 
-  if (flag) {
-    query.eq("flag", flag);
-  }
+    if (spin) {
+      query.order("spin_skill_points", { ascending: false });
+    } else {
+      query.order("skill_points", { ascending: false });
+    }
 
-  if (spin) {
-    query.order("spin_skill_points", { ascending: false });
-  } else {
-    query.order("skill_points", { ascending: false });
-  }
+    query.range(startPage, endPage);
 
-  query.range(startPage, endPage);
+    const [countQueryResult, { data: queryData }] = await Promise.all([
+      countQuery,
+      query,
+    ]);
 
-  let { data: queryData, error } = await query;
-  return {
-    total: countQuery.count || 0,
-    viewPerPage: VIEW_PER_PAGE,
-    currentPage: page,
-    userPosition: leaderPosition,
-    leaderboard: queryData?.map((user) => ({
+    const leaderboard = queryData?.map((user) => ({
       flag: user.flag,
       id: user.id,
+      avatar_url: user.avatar_url,
       play_count: user.play_count,
       skill_points: user.skill_points,
       spin_skill_points: user.spin_skill_points,
@@ -133,6 +176,92 @@ export async function getLeaderboard(
       username: user.username,
       clans: user.clans as any,
       verified: user.verified,
-    })),
+    }));
+
+    const data = {
+      cachedAt: Date.now(),
+      total: countQueryResult.count || 0,
+      leaderboard,
+    };
+
+    await setCacheValue(cacheKey, data);
+
+    return data;
+  })();
+
+  const leaderPositionPromise = (async () => {
+    if (!user) return 0;
+
+    const posCacheKey = `leaderboard:userPosition:uid=${user.id}:include_inactive=${
+      includeInactive ? 1 : 0
+    }`;
+
+    const cachedPosition = await getCacheValue<{
+      cachedAt: number;
+      position: number;
+    }>(posCacheKey);
+
+    const positionCacheFresh =
+      cachedPosition &&
+      cachedPosition.cachedAt >= cutoffInvalidation &&
+      now - cachedPosition.cachedAt < CACHE_TTL_MS;
+
+    if (positionCacheFresh) {
+      return cachedPosition.position;
+    }
+
+    if (includeInactive) {
+      const { data: profile } = await supabase
+        .from("profiles")
+        .select("id,skill_points")
+        .eq("uid", user.id)
+        .maybeSingle();
+
+      if (!profile) return 0;
+
+      const { count: playersWithMorePoints } = await supabase
+        .from("profiles")
+        .select("id", { count: "exact", head: true })
+        .neq("ban", "excluded")
+        .gt("skill_points", profile.skill_points);
+
+      const position = (playersWithMorePoints || 0) + 1;
+      await setCacheValue(posCacheKey, { cachedAt: Date.now(), position });
+      return position;
+    }
+
+    const { data: profile } = await supabase
+      .from("profiles")
+      .select("id,skill_points,scores!inner(id)")
+      .eq("uid", user.id)
+      .gte("scores.created_at", cutoffIso)
+      .limit(1, { foreignTable: "scores" })
+      .maybeSingle();
+
+    if (!profile) return 0;
+
+    const { count: playersWithMorePoints } = await supabase
+      .from("profiles")
+      .select("id,scores!inner(id)", { count: "exact", head: true })
+      .neq("ban", "excluded")
+      .gte("scores.created_at", cutoffIso)
+      .gt("skill_points", profile.skill_points);
+
+    const position = (playersWithMorePoints || 0) + 1;
+    await setCacheValue(posCacheKey, { cachedAt: Date.now(), position });
+    return position;
+  })();
+
+  const [pageData, leaderPosition] = await Promise.all([
+    pageDataPromise,
+    leaderPositionPromise,
+  ]);
+
+  return {
+    total: pageData.total,
+    viewPerPage: VIEW_PER_PAGE,
+    currentPage: page,
+    userPosition: leaderPosition,
+    leaderboard: pageData.leaderboard,
   };
 }

package/api/getOnlinePlayers.ts

@@ -1,78 +1,78 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-
-const ONLINE_WINDOW_MS = 30 * 60 * 1000;
-
-export const Schema = {
-  input: z.strictObject({}),
-  output: z.object({
-    error: z.string().optional(),
-    players: z.array(
-      z.object({
-        id: z.number(),
-        name: z.string().nullable(),
-        profilePictureUrl: z.string().nullable(),
-      })
-    ),
-  }),
-};
-
-export async function POST(request: Request): Promise<NextResponse> {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: () => {},
-    activity: handler,
-  });
-}
-
-export async function handler(
-  _data: (typeof Schema)["input"]["_type"]
-): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
-  const cutoff = Date.now() - ONLINE_WINDOW_MS;
-
-  const { data: activityRows, error: activityError } = await supabase
-    .from("profileActivities")
-    .select("uid")
-    .gt("last_activity", cutoff);
-
-  if (activityError) {
-    return NextResponse.json(
-      { players: [], error: "Failed to load online players" },
-      { status: 500 }
-    );
-  }
-
-  const onlineUids = Array.from(
-    new Set((activityRows || []).map((row) => row.uid).filter(Boolean))
-  );
-
-  if (!onlineUids.length) {
-    return NextResponse.json({ players: [] });
-  }
-
-  const { data: profiles, error: profilesError } = await supabase
-    .from("profiles")
-    .select("id,username,avatar_url,profile_image,skill_points")
-    .in("uid", onlineUids)
-    .neq("ban", "excluded")
-    .order("skill_points", { ascending: false });
-
-  if (profilesError) {
-    return NextResponse.json(
-      { players: [], error: "Failed to load online players" },
-      { status: 500 }
-    );
-  }
-
-  const players =
-    profiles?.map((profile) => ({
-      id: profile.id,
-      name: profile.username,
-      profilePictureUrl: profile.profile_image || profile.avatar_url,
-    })) || [];
-
-  return NextResponse.json({ players });
-}
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+const ONLINE_WINDOW_MS = 30 * 60 * 1000;
+
+export const Schema = {
+  input: z.strictObject({}),
+  output: z.object({
+    error: z.string().optional(),
+    players: z.array(
+      z.object({
+        id: z.number(),
+        name: z.string().nullable(),
+        profilePictureUrl: z.string().nullable(),
+      })
+    ),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(
+  _data: (typeof Schema)["input"]["_type"]
+): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  const cutoff = Date.now() - ONLINE_WINDOW_MS;
+
+  const { data: activityRows, error: activityError } = await supabase
+    .from("profileActivities")
+    .select("uid")
+    .gt("last_activity", cutoff);
+
+  if (activityError) {
+    return NextResponse.json(
+      { players: [], error: "Failed to load online players" },
+      { status: 500 }
+    );
+  }
+
+  const onlineUids = Array.from(
+    new Set((activityRows || []).map((row) => row.uid).filter(Boolean))
+  );
+
+  if (!onlineUids.length) {
+    return NextResponse.json({ players: [] });
+  }
+
+  const { data: profiles, error: profilesError } = await supabase
+    .from("profiles")
+    .select("id,username,avatar_url,profile_image,skill_points")
+    .in("uid", onlineUids)
+    .neq("ban", "excluded")
+    .order("skill_points", { ascending: false });
+
+  if (profilesError) {
+    return NextResponse.json(
+      { players: [], error: "Failed to load online players" },
+      { status: 500 }
+    );
+  }
+
+  const players =
+    profiles?.map((profile) => ({
+      id: profile.id,
+      name: profile.username,
+      profilePictureUrl: profile.avatar_url,
+    })) || [];
+
+  return NextResponse.json({ players });
+}

package/api/getProfile.ts

@@ -6,6 +6,10 @@ import { protectedApi } from "../utils/requestUtils";
 import { supabase } from "../utils/supabase";
 import { getUserBySession } from "../utils/getUserBySession";
 import { User } from "@supabase/supabase-js";
+import {
+  getActivityStatusForUserId,
+  getScoreActivityCutoffIso,
+} from "../utils/activityStatus";
 
 export const Schema = {
   input: z.strictObject({
@@ -33,6 +37,7 @@ export const Schema = {
         squares_hit: z.number().nullable(),
         total_score: z.number().nullable(),
         position: z.number().nullable(),
+        activity_status: z.enum(["active", "inactive"]),
         is_online: z.boolean(),
         clans: z
           .object({
@@ -114,6 +119,8 @@ export async function handler(
 
   const user = profiles[0];
 
+  const activityStatus = await getActivityStatusForUserId(user.id);
+
   const { data: activityData } = await supabase
     .from("profileActivities")
     .select("*")
@@ -125,12 +132,18 @@ export async function handler(
     isOnline = Date.now() - activityData.last_activity < 1800000;
   }
 
-  // Query to count how many players have more skill points than the specific player
-  const { count: playersWithMorePoints, error: rankError } = await supabase
-    .from("profiles")
-    .select(`*`, { count: "exact", head: true })
-    .neq("ban", "excluded")
-    .gt("skill_points", user.skill_points);
+  let position: number | null = null;
+  if (activityStatus === "active") {
+    const cutoffIso = getScoreActivityCutoffIso();
+    const { count: playersWithMorePoints } = await supabase
+      .from("profiles")
+      .select("id,scores!inner(id)", { count: "exact", head: true })
+      .neq("ban", "excluded")
+      .gte("scores.created_at", cutoffIso)
+      .gt("skill_points", user.skill_points);
+
+    position = (playersWithMorePoints || 0) + 1;
+  }
 
   if (user.verificationDeadline < Date.now()) {
     await supabase
@@ -145,7 +158,8 @@ export async function handler(
   return NextResponse.json({
     user: {
       ...user,
-      position: (playersWithMorePoints || 0) + 1,
+      position,
+      activity_status: activityStatus,
       is_online: isOnline,
     },
   });

package/api/getPublicStats.ts

@@ -2,6 +2,7 @@ import { NextResponse } from "next/server";
 import z from "zod";
 import { protectedApi } from "../utils/requestUtils";
 import { supabase } from "../utils/supabase";
+import { getScoreActivityCutoffIso } from "../utils/activityStatus";
 
 export const Schema = {
   input: z.strictObject({}),
@@ -103,10 +104,12 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
 
   let { data: topUsers } = await supabase
     .from("profiles")
-    .select("*")
+    .select("id,username,avatar_url,skill_points,scores!inner(id)")
     .neq("ban", "excluded")
+    .gte("scores.created_at", getScoreActivityCutoffIso())
     .order("skill_points", { ascending: false })
-    .limit(3);
+    .limit(3)
+    .limit(1, { foreignTable: "scores" });
 
   let { data: comments } = await supabase
     .from("beatmapPageComments")