rhythia-api 233.0.0 → 235.0.0

package/api/enhancedSearch.ts

@@ -1,113 +1,113 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { Database } from "../types/database";
-import { protectedApi } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-
-type EnhancedSearchRow =
-  Database["public"]["Functions"]["enhanced_search"]["Returns"][number];
-
-export const Schema = {
-  input: z.strictObject({
-    text: z.string().trim().min(1),
-    limit: z.number().int().min(1).max(25).default(10),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-    users: z.array(
-      z.object({
-        id: z.number(),
-        username: z.string().nullable(),
-        avatar_url: z.string().nullable(),
-        about_me: z.string().nullable(),
-        flag: z.string().nullable(),
-      })
-    ),
-    beatmaps: z.array(
-      z.object({
-        id: z.number(),
-        mapId: z.string().nullable(),
-        title: z.string().nullable(),
-        description: z.string().nullable(),
-        image: z.string().nullable(),
-        starRating: z.number().nullable(),
-        length: z.number().nullable(),
-        status: z.string().nullable(),
-        tags: z.string().nullable(),
-        owner: z.number().nullable(),
-        ownerUsername: z.string().nullable(),
-        ownerAvatar: 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 { data: results, error } = await supabase.rpc("enhanced_search", {
-    search_text: data.text,
-    result_limit: data.limit,
-  });
-
-  if (error) {
-    return NextResponse.json(
-      {
-        error: JSON.stringify(error),
-        users: [],
-        beatmaps: [],
-      },
-      { status: 500 }
-    );
-  }
-
-  const users: (typeof Schema)["output"]["_type"]["users"] = [];
-  const beatmaps: (typeof Schema)["output"]["_type"]["beatmaps"] = [];
-
-  for (const result of (results || []) as EnhancedSearchRow[]) {
-    if (result.result_type === "user" && result.user_id !== null) {
-      users.push({
-        id: result.user_id,
-        username: result.user_username,
-        avatar_url: result.user_avatar_url,
-        about_me: result.user_about_me,
-        flag: result.user_flag,
-      });
-      continue;
-    }
-
-    if (
-      result.result_type === "beatmap" &&
-      result.beatmap_page_id !== null
-    ) {
-      beatmaps.push({
-        id: result.beatmap_page_id,
-        mapId: result.beatmap_map_id,
-        title: result.beatmap_title,
-        description: result.beatmap_description,
-        image: result.beatmap_image,
-        starRating: result.beatmap_star_rating,
-        length: result.beatmap_length,
-        status: result.beatmap_status,
-        tags: result.beatmap_tags,
-        owner: result.beatmap_owner,
-        ownerUsername: result.beatmap_owner_username,
-        ownerAvatar: result.beatmap_owner_avatar,
-      });
-    }
-  }
-
-  return NextResponse.json({
-    users,
-    beatmaps,
-  });
-}
+import { NextResponse } from "../utils/response";
+import z from "zod";
+import { Database } from "../types/database";
+import { protectedApi } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+type EnhancedSearchRow =
+  Database["public"]["Functions"]["enhanced_search"]["Returns"][number];
+
+export const Schema = {
+  input: z.strictObject({
+    text: z.string().trim().min(1),
+    limit: z.number().int().min(1).max(25).default(10),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    users: z.array(
+      z.object({
+        id: z.number(),
+        username: z.string().nullable(),
+        avatar_url: z.string().nullable(),
+        about_me: z.string().nullable(),
+        flag: z.string().nullable(),
+      })
+    ),
+    beatmaps: z.array(
+      z.object({
+        id: z.number(),
+        mapId: z.string().nullable(),
+        title: z.string().nullable(),
+        description: z.string().nullable(),
+        image: z.string().nullable(),
+        starRating: z.number().nullable(),
+        length: z.number().nullable(),
+        status: z.string().nullable(),
+        tags: z.string().nullable(),
+        owner: z.number().nullable(),
+        ownerUsername: z.string().nullable(),
+        ownerAvatar: 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 { data: results, error } = await supabase.rpc("enhanced_search", {
+    search_text: data.text,
+    result_limit: data.limit,
+  });
+
+  if (error) {
+    return NextResponse.json(
+      {
+        error: JSON.stringify(error),
+        users: [],
+        beatmaps: [],
+      },
+      { status: 500 }
+    );
+  }
+
+  const users: (typeof Schema)["output"]["_type"]["users"] = [];
+  const beatmaps: (typeof Schema)["output"]["_type"]["beatmaps"] = [];
+
+  for (const result of (results || []) as EnhancedSearchRow[]) {
+    if (result.result_type === "user" && result.user_id !== null) {
+      users.push({
+        id: result.user_id,
+        username: result.user_username,
+        avatar_url: result.user_avatar_url,
+        about_me: result.user_about_me,
+        flag: result.user_flag,
+      });
+      continue;
+    }
+
+    if (
+      result.result_type === "beatmap" &&
+      result.beatmap_page_id !== null
+    ) {
+      beatmaps.push({
+        id: result.beatmap_page_id,
+        mapId: result.beatmap_map_id,
+        title: result.beatmap_title,
+        description: result.beatmap_description,
+        image: result.beatmap_image,
+        starRating: result.beatmap_star_rating,
+        length: result.beatmap_length,
+        status: result.beatmap_status,
+        tags: result.beatmap_tags,
+        owner: result.beatmap_owner,
+        ownerUsername: result.beatmap_owner_username,
+        ownerAvatar: result.beatmap_owner_avatar,
+      });
+    }
+  }
+
+  return NextResponse.json({
+    users,
+    beatmaps,
+  });
+}

package/api/executeAdminOperation.ts

@@ -1,4 +1,4 @@
-import { NextResponse } from "next/server";
+import { NextResponse } from "../utils/response";
 import z from "zod";
 import { Database } from "../types/database";
 import { protectedApi, validUser } from "../utils/requestUtils";
@@ -368,27 +368,6 @@ export async function handler(
 
     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({

package/api/getAvatarUploadUrl.ts

@@ -1,4 +1,4 @@
-import { NextResponse } from "next/server";
+import { NextResponse } from "../utils/response";
 import z from "zod";
 import { protectedApi, validUser } from "../utils/requestUtils";
 import { supabase } from "../utils/supabase";

package/api/getBadgeLeaders.ts

@@ -1,4 +1,4 @@
-import { NextResponse } from "next/server";
+import { NextResponse } from "../utils/response";
 import z from "zod";
 import { supabase } from "../utils/supabase";
 import { getActiveProfileIdSet } from "../utils/activityStatus";

package/api/getBadgedUsers.ts

@@ -1,4 +1,4 @@
-import { NextResponse } from "next/server";
+import { NextResponse } from "../utils/response";
 import z from "zod";
 import { protectedApi } from "../utils/requestUtils";
 import { supabase } from "../utils/supabase";

package/api/getBeatmapComments.ts

@@ -1,4 +1,4 @@
-import { NextResponse } from "next/server";
+import { NextResponse } from "../utils/response";
 import z from "zod";
 import { protectedApi, validUser } from "../utils/requestUtils";
 import { getCacheValue, setCacheValue } from "../utils/cache";

package/api/getBeatmapPage.ts

@@ -1,8 +1,8 @@
-import { NextResponse } from "next/server";
+import { NextResponse } from "../utils/response";
 import z from "zod";
 import { protectedApi } from "../utils/requestUtils";
-import { getCacheValue, setCacheValue } from "../utils/cache";
 import { supabase } from "../utils/supabase";
+import { getVisibleTopScoresForBeatmap } from "../utils/beatmapTopScores";
 
 export const Schema = {
   input: z.strictObject({
@@ -47,31 +47,31 @@ export const Schema = {
         image: z.string().nullable().optional(),
         imageLarge: z.string().nullable().optional(),
         starRating: z.number().nullable().optional(),
-        owner: z.number().nullable().optional(),
-        ownerUsername: z.string().nullable().optional(),
-        ownerAvatar: z.string().nullable().optional(),
-        status: z.string().nullable().optional(),
-        qualified: z.boolean().nullable().optional(),
-        qualifiedAt: z.string().nullable().optional(),
-        description: z.string().nullable().optional(),
-        tags: z.string().nullable().optional(),
-        videoUrl: z.string().nullable().optional(),
-        vetos: z
-          .array(
-            z.object({
-              id: z.number(),
-              userId: z.number().nullable().optional(),
-              username: z.string().nullable().optional(),
-              avatar_url: z.string().nullable().optional(),
-              veto_reason: z.string().nullable().optional(),
-              created_at: z.string().nullable().optional(),
-            })
-          )
-          .optional(),
-      })
-      .optional(),
-  }),
-};
+        owner: z.number().nullable().optional(),
+        ownerUsername: z.string().nullable().optional(),
+        ownerAvatar: z.string().nullable().optional(),
+        status: z.string().nullable().optional(),
+        qualified: z.boolean().nullable().optional(),
+        qualifiedAt: z.string().nullable().optional(),
+        description: z.string().nullable().optional(),
+        tags: z.string().nullable().optional(),
+        videoUrl: z.string().nullable().optional(),
+        vetos: z
+          .array(
+            z.object({
+              id: z.number(),
+              userId: z.number().nullable().optional(),
+              username: z.string().nullable().optional(),
+              avatar_url: z.string().nullable().optional(),
+              veto_reason: z.string().nullable().optional(),
+              created_at: z.string().nullable().optional(),
+            })
+          )
+          .optional(),
+      })
+      .optional(),
+  }),
+};
 
 export async function POST(request: Request): Promise<NextResponse> {
   return protectedApi({
@@ -106,81 +106,49 @@ export async function handler(
         noteCount,
         title
       ),
-      profiles (
-        username,
-        avatar_url
-      ),
-      vetos (
-        id,
-        user,
-        veto_reason,
-        created_at,
-        profiles (
-          id,
-          username,
-          avatar_url
-        )
-      )
-    `
-    )
+      profiles (
+        username,
+        avatar_url
+      ),
+      vetos (
+        id,
+        user,
+        veto_reason,
+        created_at,
+        profiles (
+          id,
+          username,
+          avatar_url
+        )
+      )
+    `
+    )
     .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;
+  const { scores, error: scoreError } = await getVisibleTopScoresForBeatmap(
+    beatmapHash,
+    limit
+  );
 
-  // if (isCacheable && beatmapHash) {
-  //   scoreData = await getCacheValue<any[]>(cacheKey);
-  // }
+  if (scoreError) {
+    return NextResponse.json({ error: scoreError });
+  }
 
-  // if (!scoreData) {
-  //   const { data: rpcScores, error } = await supabase.rpc(
-  //     "get_top_scores_for_beatmap",
-  //     { beatmap_hash: beatmapHash }
-  //   );
+  const mappedVetos = ((beatmapPage as any).vetos || []).map((veto: any) => ({
+    id: veto.id,
+    userId: veto.user,
+    username: veto.profiles?.username,
+    avatar_url: veto.profiles?.avatar_url,
+    veto_reason: veto.veto_reason,
+    created_at: veto.created_at,
+  }));
 
-  //   if (error) {
-  //     return NextResponse.json({ error: JSON.stringify(error) });
-  //   }
-
-  //   scoreData = (rpcScores || []).slice(0, limit);
-
-  //   if (isCacheable && beatmapHash) {
-  //     await setCacheValue(cacheKey, scoreData);
-  //   }
-  // }
-
-  const mappedVetos = ((beatmapPage as any).vetos || []).map((veto: any) => ({
-    id: veto.id,
-    userId: veto.user,
-    username: veto.profiles?.username,
-    avatar_url: veto.profiles?.avatar_url,
-    veto_reason: veto.veto_reason,
-    created_at: veto.created_at,
-  }));
-
-  return NextResponse.json({
-    scores: [].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,
-      spin: score.spin,
-      userId: score.userid,
-      username: score.username,
-      avatar_url: score.avatar_url,
-      accuracy: score.accuracy,
-    })),
+  return NextResponse.json({
+    scores,
     beatmap: {
       playcount: beatmapPage.beatmaps?.playcount,
       created_at: beatmapPage.created_at,
@@ -196,16 +164,16 @@ export async function handler(
       starRating: beatmapPage.beatmaps?.starRating,
       owner: beatmapPage.owner,
       ownerUsername: beatmapPage.profiles?.username,
-      ownerAvatar: beatmapPage.profiles?.avatar_url,
-      id: beatmapPage.id,
-      status: beatmapPage.status,
-      qualified: beatmapPage.qualified,
-      qualifiedAt: beatmapPage.qualifiedAt,
-      nominations: beatmapPage.nominations as number[],
-      description: beatmapPage.description,
-      tags: beatmapPage.tags,
-      videoUrl: beatmapPage.video_url,
-      vetos: mappedVetos.length > 0 ? mappedVetos : undefined,
-    },
-  });
-}
+      ownerAvatar: beatmapPage.profiles?.avatar_url,
+      id: beatmapPage.id,
+      status: beatmapPage.status,
+      qualified: beatmapPage.qualified,
+      qualifiedAt: beatmapPage.qualifiedAt,
+      nominations: beatmapPage.nominations as number[],
+      description: beatmapPage.description,
+      tags: beatmapPage.tags,
+      videoUrl: beatmapPage.video_url,
+      vetos: mappedVetos.length > 0 ? mappedVetos : undefined,
+    },
+  });
+}