rhythia-api 230.0.0 → 231.0.0

package/api/{approveMap.ts → vetoMap.ts}

@@ -1,78 +1,94 @@
-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";
-
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    mapId: z.number(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-  }),
-};
-
-export async function POST(request: Request) {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: validUser,
-    activity: handler,
-  });
-}
-
-export async function handler(data: (typeof Schema)["input"]["_type"]) {
-  const user = (await getUserBySession(data.session)) as User;
-  let { data: queryUserData, error: userError } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("uid", user.id)
-    .single();
-
-  if (!queryUserData) {
-    return NextResponse.json({ error: "Can't find user" });
-  }
-
-  const tags = (queryUserData?.badges || []) as string[];
-
-  if (!tags.includes("MMT")) {
-    return NextResponse.json({ error: "Only MMTs can approve maps!" });
-  }
-
-  const { data: mapData, error } = await supabase
-    .from("beatmapPages")
-    .select("id,nominations,owner")
-    .eq("id", data.mapId)
-    .single();
-
-  if (!mapData) {
-    return NextResponse.json({ error: "Bad map" });
-  }
-
-  if (mapData.owner == queryUserData.id) {
-    return NextResponse.json({ error: "Can't approve own map" });
-  }
-
-  if ((mapData.nominations as number[])!.length < 2) {
-    return NextResponse.json({
-      error: "Maps can get approved only if they have 2 nominations",
-    });
-  }
-
-  if ((mapData.nominations as number[]).includes(queryUserData.id)) {
-    return NextResponse.json({
-      error: "Can't nominate and approve",
-    });
-  }
-
-  await supabase.from("beatmapPages").upsert({
-    id: data.mapId,
-    status: "RANKED",
-    ranked_at: Date.now(),
-  });
-
-  return NextResponse.json({});
-}
+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";
+
+const VETO_BADGES = ["Team Ranked"];
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    mapId: z.number(),
+    reason: z.string().min(1).max(1000),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  const user = (await getUserBySession(data.session)) as User;
+  const { data: queryUserData } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id)
+    .single();
+
+  if (!queryUserData) {
+    return NextResponse.json({ error: "Can't find user" });
+  }
+
+  const tags = (queryUserData?.badges || []) as string[];
+  const hasVetoAccess = VETO_BADGES.some((badge) => tags.includes(badge));
+
+  if (!hasVetoAccess) {
+    return NextResponse.json({ error: "Only management can veto maps!" });
+  }
+
+  const { data: mapData } = await supabase
+    .from("beatmapPages")
+    .select("id,qualified")
+    .eq("id", data.mapId)
+    .single();
+
+  if (!mapData) {
+    return NextResponse.json({ error: "Bad map" });
+  }
+
+  if (!mapData.qualified) {
+    return NextResponse.json({
+      error: "Only qualified maps can be vetoed",
+    });
+  }
+
+  const { data: vetoData, error: vetoError } = await supabase
+    .from("vetos")
+    .insert({
+      beatmapPage: data.mapId,
+      user: queryUserData.id,
+      veto_reason: data.reason,
+    })
+    .select("id")
+    .single();
+
+  if (vetoError) {
+    return NextResponse.json({ error: vetoError.message });
+  }
+
+  const { error: updateError } = await supabase.from("beatmapPages").upsert({
+    id: data.mapId,
+    qualified: false,
+    qualifiedAt: null,
+  });
+
+  if (updateError) {
+    if (vetoData?.id) {
+      await supabase.from("vetos").delete().eq("id", vetoData.id);
+    }
+
+    return NextResponse.json({ error: updateError.message });
+  }
+
+  return NextResponse.json({});
+}

package/index.ts

@@ -33,22 +33,6 @@ import { Schema as AddCollectionMap } from "./api/addCollectionMap"
 export { Schema as SchemaAddCollectionMap } from "./api/addCollectionMap"
 export const addCollectionMap = handleApi({url:"/api/addCollectionMap",...AddCollectionMap})
 
-// ./api/approveMap.ts API
-
-/*
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    mapId: z.number(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-  }),
-};*/
-import { Schema as ApproveMap } from "./api/approveMap"
-export { Schema as SchemaApproveMap } from "./api/approveMap"
-export const approveMap = handleApi({url:"/api/approveMap",...ApproveMap})
-
 // ./api/chartPublicStats.ts API
 
 /*
@@ -60,6 +44,22 @@ import { Schema as ChartPublicStats } from "./api/chartPublicStats"
 export { Schema as SchemaChartPublicStats } from "./api/chartPublicStats"
 export const chartPublicStats = handleApi({url:"/api/chartPublicStats",...ChartPublicStats})
 
+// ./api/checkQualified.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    secret: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    updated: z.number(),
+  }),
+};*/
+import { Schema as CheckQualified } from "./api/checkQualified"
+export { Schema as SchemaCheckQualified } from "./api/checkQualified"
+export const checkQualified = handleApi({url:"/api/checkQualified",...CheckQualified})
+
 // ./api/createBeatmap.ts API
 
 /*
@@ -469,16 +469,30 @@ 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(),
-        description: z.string().nullable().optional(),
-        tags: z.string().nullable().optional(),
-        videoUrl: z.string().nullable().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(),
+  }),
 };*/
 import { Schema as GetBeatmapPage } from "./api/getBeatmapPage"
 export { Schema as SchemaGetBeatmapPage } from "./api/getBeatmapPage"
@@ -528,14 +542,28 @@ export const Schema = {
         beatmapFile: z.string().nullable().optional(),
         image: 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(),
-        videoUrl: z.string().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(),
+        videoUrl: z.string().nullable(),
+        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(),
+  }),
 };*/
 import { Schema as GetBeatmapPageById } from "./api/getBeatmapPageById"
 export { Schema as SchemaGetBeatmapPageById } from "./api/getBeatmapPageById"
@@ -1216,22 +1244,6 @@ import { Schema as GetVideoUploadUrl } from "./api/getVideoUploadUrl"
 export { Schema as SchemaGetVideoUploadUrl } from "./api/getVideoUploadUrl"
 export const getVideoUploadUrl = handleApi({url:"/api/getVideoUploadUrl",...GetVideoUploadUrl})
 
-// ./api/nominateMap.ts API
-
-/*
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    mapId: z.number(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-  }),
-};*/
-import { Schema as NominateMap } from "./api/nominateMap"
-export { Schema as SchemaNominateMap } from "./api/nominateMap"
-export const nominateMap = handleApi({url:"/api/nominateMap",...NominateMap})
-
 // ./api/postBeatmapComment.ts API
 
 /*
@@ -1249,6 +1261,23 @@ import { Schema as PostBeatmapComment } from "./api/postBeatmapComment"
 export { Schema as SchemaPostBeatmapComment } from "./api/postBeatmapComment"
 export const postBeatmapComment = handleApi({url:"/api/postBeatmapComment",...PostBeatmapComment})
 
+// ./api/qualifyMap.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    mapId: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    qualifiedAt: z.string().optional(),
+  }),
+};*/
+import { Schema as QualifyMap } from "./api/qualifyMap"
+export { Schema as SchemaQualifyMap } from "./api/qualifyMap"
+export const qualifyMap = handleApi({url:"/api/qualifyMap",...QualifyMap})
+
 // ./api/rankMapsArchive.ts API
 
 /*
@@ -1338,26 +1367,26 @@ export const submitScore = handleApi({url:"/api/submitScore",...SubmitScore})
 // ./api/submitScoreInternal.ts API
 
 /*
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    secret: z.string(),
-    token: z.string(),
-    data: z.strictObject({
-      onlineMapId: z.number(),
-      misses: z.number(),
-      hits: z.number(),
-      speed: z.number(),
-      mods: z.array(z.string()),
-      spin: z.boolean(),
-      replayBytes: z.string().nullable().optional(),
-      pauses: z.number().nullable().optional(),
-      failTime: z.number().nullable().optional(),
-    }),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-  }),
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    secret: z.string(),
+    token: z.string(),
+    data: z.strictObject({
+      onlineMapId: z.number(),
+      misses: z.number(),
+      hits: z.number(),
+      speed: z.number(),
+      mods: z.array(z.string()),
+      spin: z.boolean(),
+      replayBytes: z.string().nullable().optional(),
+      pauses: z.number().nullable().optional(),
+      failTime: z.number().nullable().optional(),
+    }),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
 };*/
 import { Schema as SubmitScoreInternal } from "./api/submitScoreInternal"
 export { Schema as SchemaSubmitScoreInternal } from "./api/submitScoreInternal"
@@ -1382,4 +1411,21 @@ export const Schema = {
 import { Schema as UpdateBeatmapPage } from "./api/updateBeatmapPage"
 export { Schema as SchemaUpdateBeatmapPage } from "./api/updateBeatmapPage"
 export const updateBeatmapPage = handleApi({url:"/api/updateBeatmapPage",...UpdateBeatmapPage})
+
+// ./api/vetoMap.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    mapId: z.number(),
+    reason: z.string().min(1).max(1000),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};*/
+import { Schema as VetoMap } from "./api/vetoMap"
+export { Schema as SchemaVetoMap } from "./api/vetoMap"
+export const vetoMap = handleApi({url:"/api/vetoMap",...VetoMap})
 export { handleApi } from "./handleApi"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "230.0.0",
+  "version": "231.0.0",
   "main": "index.ts",
   "author": "online-contributors-cunev",
   "scripts": {
@@ -8,6 +8,7 @@
     "ci-deploy": "tsx ./scripts/ci-deploy.ts",
     "test": "tsx ./scripts/test.ts",
     "cache:clear-user-scores": "bun run scripts/clear-user-score-cache.ts",
+    "db:optimize-user-scores": "bun run scripts/optimize-user-scores-indexes.ts",
     "query-pull": "bun run scripts/pull-queries.ts",
     "query-push": "bun run scripts/deploy-queries.ts",
     "queries:pull": "bun run scripts/pull-queries.ts",
@@ -52,7 +53,7 @@
     "sharp": "^0.33.5",
     "short-uuid": "^5.2.0",
     "simple-git": "^3.25.0",
-    "supabase": "^2.76.15",
+    "supabase": "^2.76.16",
     "tsx": "^4.17.0",
     "utf-8-validate": "^6.0.4",
     "uuid": "^11.1.0",
@@ -61,4 +62,4 @@
     "zod": "^3.24.2"
   },
   "packageManager": "yarn@1.22.22"
-}
+}

package/queries/get_user_scores_lastday.sql

@@ -3,12 +3,23 @@ CREATE OR REPLACE FUNCTION public.get_user_scores_lastday(userid integer, limit_
  LANGUAGE sql
 AS $function$
   with s as (
-    select *
-    from public.scores
-    where "userId" = userid
-      and passed = true
-    order by created_at desc
-    limit least(limit_param, 100)
+    select
+      sc.created_at,
+      sc.id,
+      sc.passed,
+      sc."userId",
+      sc.awarded_sp,
+      sc."beatmapHash",
+      sc.misses,
+      sc.replay_url,
+      sc."songId",
+      sc.speed,
+      sc.spin
+    from public.scores sc
+    where sc."userId" = userid
+      and sc.passed = true
+    order by sc.created_at desc
+    limit least(coalesce(limit_param, 100), 100)
   )
   select coalesce(
            jsonb_agg(

package/queries/get_user_scores_top_and_stats.sql

@@ -1,24 +1,8 @@
 CREATE OR REPLACE FUNCTION public.get_user_scores_top_and_stats(userid integer, limit_param integer)
  RETURNS jsonb
- LANGUAGE plpgsql
+ LANGUAGE sql
 AS $function$
-declare
-  top_json     jsonb := '[]'::jsonb;
-  total_scores int := 0;
-  spin_scores  int := 0;
-begin
-  -- stats
-  select
-    count(*)::int,
-    count(*) filter (where spin = true)::int
-  into total_scores, spin_scores
-  from public.scores s
-  where s."userId" = userid
-    and s.passed = true
-    and s.awarded_sp is not null and s.awarded_sp <> 0;
-
-  -- top
-  with base as (
+  with filtered as materialized (
     select
       s.created_at,
       s.id,
@@ -34,51 +18,67 @@ begin
     from public.scores s
     where s."userId" = userid
       and s.passed = true
-      and s.awarded_sp is not null and s.awarded_sp <> 0
+      and s.awarded_sp is not null
+      and s.awarded_sp <> 0
   ),
-  best_per_hash as (
-    select distinct on ("beatmapHash") *
-    from base
-    order by "beatmapHash", awarded_sp desc
+  stats as (
+    select
+      count(*)::int as total_scores,
+      count(*) filter (where spin = true)::int as spin_scores
+    from filtered
   ),
   top_rows as (
     select *
-    from best_per_hash
+    from (
+      select distinct on (f."beatmapHash")
+        f.created_at,
+        f.id,
+        f.passed,
+        f."userId",
+        f.awarded_sp,
+        f."beatmapHash",
+        f.misses,
+        f.replay_url,
+        f."songId",
+        f.speed,
+        f.spin
+      from filtered f
+      order by f."beatmapHash", f.awarded_sp desc
+    ) best_per_hash
     order by awarded_sp desc
-    limit least(limit_param, 100)
+    limit least(coalesce(limit_param, 100), 100)
+  ),
+  top_json as (
+    select coalesce(
+             jsonb_agg(
+               jsonb_build_object(
+                 'created_at',        t.created_at,
+                 'id',                t.id,
+                 'passed',            t.passed,
+                 'userId',            t."userId",
+                 'awarded_sp',        t.awarded_sp,
+                 'beatmapHash',       t."beatmapHash",
+                 'misses',            t.misses,
+                 'replay_url',        t.replay_url,
+                 'rank',              null, -- keep key for Zod compatibility
+                 'songId',            t."songId",
+                 'beatmapDifficulty', b.difficulty,
+                 'beatmapNotes',      b."noteCount",
+                 'beatmapTitle',      b.title,
+                 'speed',             t.speed,
+                 'spin',              t.spin
+               )
+             ),
+             '[]'::jsonb
+           ) as value
+    from top_rows t
+    left join public.beatmaps b on b."beatmapHash" = t."beatmapHash"
   )
-  select coalesce(
-           jsonb_agg(
-             jsonb_build_object(
-               'created_at',        t.created_at,
-               'id',                t.id,
-               'passed',            t.passed,
-               'userId',            t."userId",
-               'awarded_sp',        t.awarded_sp,
-               'beatmapHash',       t."beatmapHash",
-               'misses',            t.misses,
-               'replay_url',        t.replay_url,
-               'rank',              null, -- keep key for Zod compatibility
-               'songId',            t."songId",
-               'beatmapDifficulty', b.difficulty,
-               'beatmapNotes',      b."noteCount",
-               'beatmapTitle',      b.title,
-               'speed',             t.speed,
-               'spin',              t.spin
-             )
-           ),
-           '[]'::jsonb
-         )
-  into top_json
-  from top_rows t
-  left join public.beatmaps b on b."beatmapHash" = t."beatmapHash";
-
-  return jsonb_build_object(
-    'top',   top_json,
-    'stats', jsonb_build_object(
-               'totalScores', total_scores,
-               'spinScores',  spin_scores
-             )
-  );
-end;
+  select jsonb_build_object(
+           'top',   (select value from top_json),
+           'stats', jsonb_build_object(
+                      'totalScores', coalesce((select total_scores from stats), 0),
+                      'spinScores',  coalesce((select spin_scores from stats), 0)
+                    )
+         );
 $function$