rhythia-api 137.0.0 → 139.0.0

package/api/createBeatmap.ts

@@ -77,14 +77,15 @@ export async function handler({
   });
 
   await s3Client.send(command);
-  parsedData.markers.sort((a, b) => a.position - b.position);
+  const markers = parsedData.markers.sort((a, b) => a.position - b.position);
+
   const upserted = await supabase.from("beatmaps").upsert({
     beatmapHash: digested,
     title: parsedData.strings.mapName,
     playcount: 0,
     difficulty: parsedData.metadata.difficulty,
     noteCount: parsedData.metadata.noteCount,
-    length: parsedData.pointers.audioLength,
+    length: markers[markers.length - 1].position,
     beatmapFile: url,
     image: `https://static.rhythia.com/${imgkey}`,
     starRating: rateMap(parsedData),

package/api/deleteBeatmapPage.ts

@@ -0,0 +1,69 @@
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    id: z.number(),
+  }),
+  output: z.strictObject({
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler({
+  session,
+  id,
+}: (typeof Schema)["input"]["_type"]): Promise<
+  NextResponse<(typeof Schema)["output"]["_type"]>
+> {
+  const user = (await supabase.auth.getUser(session)).data.user!;
+  let { data: userData, error: userError } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id)
+    .single();
+
+  let { data: pageData, error: pageError } = await supabase
+    .from("beatmapPages")
+    .select("*")
+    .eq("id", id)
+    .single();
+
+  if (!pageData) return NextResponse.json({ error: "No beatmap." });
+
+  let { data: beatmapData, error: bmPageError } = await supabase
+    .from("beatmaps")
+    .select("*")
+    .eq("beatmapHash", pageData.id)
+    .single();
+
+  if (!userData) return NextResponse.json({ error: "No user." });
+  if (!beatmapData) return NextResponse.json({ error: "No beatmap." });
+
+  if (userData.id !== pageData.owner)
+    return NextResponse.json({ error: "Non-authz user." });
+
+  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("beatmapPages").delete().eq("id", id);
+  await supabase
+    .from("beatmaps")
+    .delete()
+    .eq("beatmapHash", beatmapData.beatmapHash);
+
+  return NextResponse.json({});
+}

package/api/getBeatmaps.ts

@@ -11,6 +11,8 @@ export const Schema = {
     tagsFilter: z.string().optional(),
     page: z.number().default(1),
     maxStars: z.number().optional(),
+    minLength: z.number().optional(),
+    maxLength: z.number().optional(),
     minStars: z.number().optional(),
     creator: z.number().optional(),
     status: z.string().optional(),
@@ -86,6 +88,7 @@ export async function getBeatmaps(data: (typeof Schema)["input"]["_type"]) {
           image,
           starRating,
           difficulty,
+          length,
           title
         ),
         profiles!inner(
@@ -113,6 +116,15 @@ export async function getBeatmaps(data: (typeof Schema)["input"]["_type"]) {
   if (data.maxStars) {
     qry = qry.lt("beatmaps.starRating", data.maxStars);
   }
+
+  if (data.minLength) {
+    qry = qry.gt("beatmaps.length", data.minLength);
+  }
+
+  if (data.maxLength) {
+    qry = qry.lt("beatmaps.length", data.maxLength);
+  }
+
   if (data.status) {
     qry = qry.eq("status", data.status);
   }
@@ -135,6 +147,7 @@ export async function getBeatmaps(data: (typeof Schema)["input"]["_type"]) {
       difficulty: beatmapPage.beatmaps?.difficulty,
       title: beatmapPage.beatmaps?.title,
       ranked: beatmapPage.beatmaps?.ranked,
+      length: beatmapPage.beatmaps?.length,
       beatmapFile: beatmapPage.beatmaps?.beatmapFile,
       image: beatmapPage.beatmaps?.image,
       starRating: beatmapPage.beatmaps?.starRating,

package/api/submitScore.ts

@@ -60,7 +60,7 @@ export async function handler({
   console.log(userData);
   let { data: beatmaps, error } = await supabase
     .from("beatmaps")
-    .select("playcount")
+    .select("*")
     .eq("beatmapHash", data.mapHash)
     .single();
 
@@ -81,10 +81,33 @@ export async function handler({
 
   let newPlaycount = 1;
 
-  if (beatmaps) {
-    newPlaycount = (beatmaps.playcount || 1) + 1;
+  if (!beatmaps) {
+    return NextResponse.json(
+      {
+        error: "Map not submitted",
+      },
+      { status: 500 }
+    );
+  }
+
+  if (beatmaps.noteCount !== data.mapNoteCount) {
+    return NextResponse.json(
+      {
+        error: "Wrong map",
+      },
+      { status: 500 }
+    );
+  }
+  if (beatmaps.noteCount !== data.mapNoteCount) {
+    return NextResponse.json(
+      {
+        error: "Wrong map",
+      },
+      { status: 500 }
+    );
   }
 
+  newPlaycount = (beatmaps.playcount || 1) + 1;
   await supabase.from("beatmaps").upsert({
     beatmapHash: data.mapHash,
     title: data.mapTitle,

package/api/updateBeatmapPage.ts

@@ -8,6 +8,8 @@ export const Schema = {
     session: z.string(),
     id: z.number(),
     beatmapHash: z.string(),
+    tags: z.string(),
+    description: z.string(),
   }),
   output: z.strictObject({
     error: z.string().optional(),
@@ -27,6 +29,8 @@ export async function handler({
   session,
   beatmapHash,
   id,
+  description,
+  tags,
 }: (typeof Schema)["input"]["_type"]): Promise<
   NextResponse<(typeof Schema)["output"]["_type"]>
 > {
@@ -55,6 +59,9 @@ export async function handler({
   if (userData.id !== pageData?.owner)
     return NextResponse.json({ error: "Non-authz user." });
 
+  if (pageData?.status !== "UNRANKED")
+    return NextResponse.json({ error: "Only unranked maps can be updated" });
+
   const upserted = await supabase
     .from("beatmapPages")
     .upsert({
@@ -64,6 +71,8 @@ export async function handler({
       title: beatmapData.title,
       status: "UNRANKED",
       owner: userData.id,
+      description,
+      tags,
     })
     .select("*")
     .single();

package/index.ts

@@ -15,6 +15,11 @@ import { Schema as CreateBeatmapPage } from "./api/createBeatmapPage"
 export { Schema as SchemaCreateBeatmapPage } from "./api/createBeatmapPage"
 export const createBeatmapPage = handleApi({url:"/api/createBeatmapPage",...CreateBeatmapPage})
 
+// ./api/deleteBeatmapPage.ts API
+import { Schema as DeleteBeatmapPage } from "./api/deleteBeatmapPage"
+export { Schema as SchemaDeleteBeatmapPage } from "./api/deleteBeatmapPage"
+export const deleteBeatmapPage = handleApi({url:"/api/deleteBeatmapPage",...DeleteBeatmapPage})
+
 // ./api/editAboutMe.ts API
 import { Schema as EditAboutMe } from "./api/editAboutMe"
 export { Schema as SchemaEditAboutMe } from "./api/editAboutMe"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "137.0.0",
+  "version": "139.0.0",
   "main": "index.ts",
   "scripts": {
     "update": "bun ./scripts/update.ts",