rhythia-api 216.0.0 → 217.0.0

package/api/deleteBeatmapPage.ts

@@ -1,9 +1,10 @@
 import { NextResponse } from "next/server";
 import z from "zod";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-import { getUserBySession } from "../utils/getUserBySession";
-import { User } from "@supabase/supabase-js";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+import { getUserBySession } from "../utils/getUserBySession";
+import { User } from "@supabase/supabase-js";
+import { invalidateCache, invalidateCachePrefix } from "../utils/cache";
 
 export const Schema = {
   input: z.strictObject({
@@ -54,24 +55,30 @@ export async function handler({
   if (!userData) return NextResponse.json({ error: "No user." });
   if (!beatmapData) return NextResponse.json({ error: "No beatmap." });
 
-  if (userData.id !== pageData.owner) {
-    const isDev =
-      (userData.badges as string[]).includes("Developer") ||
-      (userData.badges as string[]).includes("Global Moderator");
+  const badges = (userData.badges || []) as string[];
+  const hasDeletionRole = badges.includes("RCT") || badges.includes("MMT");
 
-    if (!isDev) return NextResponse.json({ error: "Non-authz user." });
+  if (!hasDeletionRole) {
+    return NextResponse.json({
+      error: "Only RCT or MMT members can delete beatmaps.",
+    });
   }
 
   if (pageData.status !== "UNRANKED")
     return NextResponse.json({ error: "Only unranked maps can be updated" });
 
-  await supabase.from("beatmapPageComments").delete().eq("beatmapPage", id);
-  await supabase.from("collectionRelations").delete().eq("beatmapPage", id);
-  await supabase.from("beatmapPages").delete().eq("id", id);
-  await supabase
-    .from("beatmaps")
-    .delete()
-    .eq("beatmapHash", beatmapData.beatmapHash);
-
-  return NextResponse.json({});
-}
+  await supabase.from("beatmapPageComments").delete().eq("beatmapPage", id);
+  await supabase.from("collectionRelations").delete().eq("beatmapPage", id);
+  await supabase.from("beatmapPages").delete().eq("id", id);
+  await supabase
+    .from("beatmaps")
+    .delete()
+    .eq("beatmapHash", beatmapData.beatmapHash);
+
+  await invalidateCache(`beatmap-comments:${id}`);
+  if (pageData.latestBeatmapHash) {
+    await invalidateCachePrefix(`beatmap-scores:${pageData.latestBeatmapHash}`);
+  }
+
+  return NextResponse.json({});
+}

package/api/executeAdminOperation.ts

@@ -1,10 +1,11 @@
 import { NextResponse } from "next/server";
-import z from "zod";
-import { Database } from "../types/database";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-import { getUserBySession } from "../utils/getUserBySession";
-import { User } from "@supabase/supabase-js";
+import z from "zod";
+import { Database } from "../types/database";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+import { getUserBySession } from "../utils/getUserBySession";
+import { User } from "@supabase/supabase-js";
+import { invalidateCache, invalidateCachePrefix } from "../utils/cache";
 
 // Define supported admin operations and their parameter types
 const adminOperations = {
@@ -145,17 +146,21 @@ export async function handler(
       { status: 403 }
     );
   }
-
-  // Execute the requested admin operation
-  try {
-    let result;
-    const operation = data.data.operation;
-    const params = data.data.params as any;
-
-    switch (operation) {
-      case "deleteUser":
-        result = await supabase.rpc("admin_delete_user", {
-          user_id: params.userId,
+
+  // Execute the requested admin operation
+  try {
+    let result: { data?: any; error?: any } | null = null;
+    const operation = data.data.operation;
+    const params = data.data.params as any;
+    const targetUserId =
+      "userId" in params && typeof params.userId === "number"
+        ? params.userId
+        : null;
+
+    switch (operation) {
+      case "deleteUser":
+        result = await supabase.rpc("admin_delete_user", {
+          user_id: params.userId,
         });
         break;
 
@@ -216,21 +221,23 @@ export async function handler(
           })
           .select();
         break;
-      case "changeBadges":
-        // Allow only developers to modify badges.
-        if ((queryUserData.badges as string[]).includes("Developer")) {
-          result = await supabase
-            .from("profiles")
-            .upsert({
-              id: params.userId,
-              badges: JSON.parse(params.badges),
-            })
-            .select();
-        }
-        break;
-
-      case "addBadge":
-        // Allow only developers to modify badges.
+      case "changeBadges":
+        // Allow only developers to modify badges.
+        if ((queryUserData.badges as string[]).includes("Developer")) {
+          result = await supabase
+            .from("profiles")
+            .upsert({
+              id: params.userId,
+              badges: JSON.parse(params.badges),
+            })
+            .select();
+        } else {
+          result = { data: null, error: { message: "Unauthorized" } };
+        }
+        break;
+
+      case "addBadge":
+        // Allow only developers to modify badges.
         if ((queryUserData.badges as string[]).includes("Developer")) {
           // Get current badges
           const { data: targetUser } = await supabase
@@ -242,21 +249,23 @@ export async function handler(
           const currentBadges = (targetUser?.badges || []) as string[];
           if (!currentBadges.includes(params.badge)) {
             currentBadges.push(params.badge);
-            result = await supabase
-              .from("profiles")
-              .upsert({
-                id: params.userId,
-                badges: currentBadges,
-              })
-              .select();
-          } else {
-            result = { data: targetUser, error: null };
-          }
-        }
-        break;
-
-      case "removeBadge":
-        // Allow only developers to modify badges.
+            result = await supabase
+              .from("profiles")
+              .upsert({
+                id: params.userId,
+                badges: currentBadges,
+              })
+              .select();
+          } else {
+            result = { data: targetUser, error: null };
+          }
+        } else {
+          result = { data: null, error: { message: "Unauthorized" } };
+        }
+        break;
+
+      case "removeBadge":
+        // Allow only developers to modify badges.
         if ((queryUserData.badges as string[]).includes("Developer")) {
           // Get current badges
           const { data: targetUser } = await supabase
@@ -268,15 +277,17 @@ export async function handler(
           const currentBadges = (targetUser?.badges || []) as string[];
           const updatedBadges = currentBadges.filter(b => b !== params.badge);
           
-          result = await supabase
-            .from("profiles")
-            .upsert({
-              id: params.userId,
-              badges: updatedBadges,
-            })
-            .select();
-        }
-        break;
+          result = await supabase
+            .from("profiles")
+            .upsert({
+              id: params.userId,
+              badges: updatedBadges,
+            })
+            .select();
+        } else {
+          result = { data: null, error: { message: "Unauthorized" } };
+        }
+        break;
 
       case "getScoresPaginated":
         const offset = (params.page - 1) * params.limit;
@@ -338,27 +349,52 @@ export async function handler(
     }
 
     // Log the admin action
-    await supabase.rpc("admin_log_action", {
-      admin_id: queryUserData.id,
-      action_type: operation,
-      target_id: "userId" in params ? params.userId : null,
-      details: { params },
-    });
-
-    if (result.error) {
-      return NextResponse.json(
-        {
-          success: false,
-          error: result.error.message,
-        },
-        { status: 500 }
-      );
-    }
-
-    return NextResponse.json({
-      success: true,
-      result: result.data,
-    });
+    await supabase.rpc("admin_log_action", {
+      admin_id: queryUserData.id,
+      action_type: operation,
+      target_id: "userId" in params ? params.userId : null,
+      details: { params },
+    });
+
+    if (result?.error) {
+      return NextResponse.json(
+        {
+          success: false,
+          error: result.error.message,
+        },
+        { status: 500 }
+      );
+    }
+
+    if (targetUserId !== null && !result?.error) {
+      await invalidateCachePrefix(`userscore:${targetUserId}`);
+
+      if (
+        operation === "removeAllScores" ||
+        operation === "invalidateRankedScores" ||
+        operation === "deleteUser"
+      ) {
+        const { data: beatmapHashes } = await supabase
+          .from("scores")
+          .select("beatmapHash")
+          .eq("userId", targetUserId);
+
+        const uniqueHashes = new Set(
+          (beatmapHashes || [])
+            .map((row) => row.beatmapHash)
+            .filter((hash): hash is string => Boolean(hash))
+        );
+
+        for (const hash of uniqueHashes) {
+          await invalidateCachePrefix(`beatmap-scores:${hash}`);
+        }
+      }
+    }
+
+    return NextResponse.json({
+      success: true,
+      result: result?.data,
+    });
   } catch (err: any) {
     return NextResponse.json(
       {

package/api/getBeatmapComments.ts

@@ -1,7 +1,8 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { getCacheValue, setCacheValue } from "../utils/cache";
+import { supabase } from "../utils/supabase";
 
 export const Schema = {
   input: z.strictObject({
@@ -34,16 +35,25 @@ export async function POST(request: Request): Promise<NextResponse> {
   });
 }
 
-export async function handler({
-  page,
-}: (typeof Schema)["input"]["_type"]): Promise<
-  NextResponse<(typeof Schema)["output"]["_type"]>
-> {
-  let { data: userData, error: userError } = await supabase
-    .from("beatmapPageComments")
-    .select(
-      `
-      *,
+export async function handler({
+  page,
+}: (typeof Schema)["input"]["_type"]): Promise<
+  NextResponse<(typeof Schema)["output"]["_type"]>
+> {
+  const cacheKey = `beatmap-comments:${page}`;
+  const cachedComments = await getCacheValue<
+    (typeof Schema)["output"]["_type"]["comments"]
+  >(cacheKey);
+
+  if (cachedComments) {
+    return NextResponse.json({ comments: cachedComments });
+  }
+
+  let { data: userData, error: userError } = await supabase
+    .from("beatmapPageComments")
+    .select(
+      `
+      *,
       profiles!inner(
           username,
           avatar_url,
@@ -51,7 +61,11 @@ export async function handler({
         )
       `
     )
-    .eq("beatmapPage", page);
-
-  return NextResponse.json({ comments: userData! });
-}
+    .eq("beatmapPage", page);
+
+  if (userData) {
+    await setCacheValue(cacheKey, userData);
+  }
+
+  return NextResponse.json({ comments: userData! });
+}

package/api/getBeatmapPage.ts

@@ -1,17 +1,19 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi } from "../utils/requestUtils";
-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";
 
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    id: z.number(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-    scores: z
-      .array(
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    id: z.number(),
+    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(),
@@ -66,15 +68,17 @@ 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"]>> {
-  let { data: beatmapPage, error: errorlast } = await supabase
-    .from("beatmapPages")
-    .select(
-      `
-      *,
+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(
+      `
+      *,
       beatmaps (
         created_at,
         playcount,
@@ -93,28 +97,47 @@ export async function handler(
         avatar_url
       )
     `
-    )
-    .eq("id", data.id)
-    .single();
-
-  const { data: scoreData, error } = await supabase.rpc(
-    "get_top_scores_for_beatmap",
-    { beatmap_hash: beatmapPage?.latestBeatmapHash || "" }
-  );
-
-  if (error) {
-    return NextResponse.json({ error: JSON.stringify(error) });
-  }
-
-  if (!beatmapPage) return NextResponse.json({});
-
-  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("id", data.id)
+    .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,
       passed: score.passed,
       songId: score.songid,
       speed: score.speed,

package/api/getBeatmapPageById.ts

@@ -1,17 +1,19 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi } from "../utils/requestUtils";
-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";
 
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    mapId: z.string(),
-  }),
-  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(),
@@ -62,12 +64,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"]>> {
-  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(
       `
       *,
@@ -89,27 +93,46 @@ export async function handler(
       )
     `
     )
-    .eq("latestBeatmapHash", data.mapId)
-    .single();
-
-  if (!beatmapPage) return NextResponse.json({});
-
-  const { data: scoreData, error } = await supabase.rpc(
-    "get_top_scores_for_beatmap",
-    { beatmap_hash: beatmapPage?.latestBeatmapHash || "" }
-  );
-
-  if (error) {
-    return NextResponse.json({ error: JSON.stringify(error) });
-  }
-
-  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}: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,
       passed: score.passed,
       songId: score.songid,
       speed: score.speed,