rhythia-api 149.0.0 → 151.0.0

package/api/createBeatmap.ts

@@ -101,6 +101,15 @@ export async function handler({
       .toBuffer();
   } catch (error) {}
 
+  let largeBuffer = Buffer.from([]);
+  try {
+    largeBuffer = await require("sharp")(parsedData.cover)
+      .resize(850)
+      .jpeg({ mozjpeg: true })
+      .toBuffer();
+  } catch (error) {}
+
+  // Images
   const command = new PutObjectCommand({
     Bucket: "rhthia-avatars",
     Key: imgkey,
@@ -109,6 +118,17 @@ export async function handler({
   });
 
   await s3Client.send(command);
+
+  const command2 = new PutObjectCommand({
+    Bucket: "rhthia-avatars",
+    Key: imgkey + "large",
+    Body: largeBuffer,
+    ContentType: "image/jpeg",
+  });
+
+  await s3Client.send(command2);
+  // Images End
+
   const markers = parsedData.markers.sort((a, b) => a.position - b.position);
 
   const upserted = await supabase.from("beatmaps").upsert({
@@ -120,6 +140,7 @@ export async function handler({
     length: markers[markers.length - 1].position,
     beatmapFile: url,
     image: `https://static.rhythia.com/${imgkey}`,
+    imageLarge: `https://static.rhythia.com/${imgkey}large`,
     starRating: rateMap(parsedData),
   });
 

package/api/getBeatmapPage.ts

@@ -23,6 +23,7 @@ export const Schema = {
         ranked: z.boolean().nullable().optional(),
         beatmapFile: z.string().nullable().optional(),
         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(),
@@ -60,6 +61,7 @@ export async function handler(
         ranked,
         beatmapFile,
         image,
+        imageLarge,
         starRating,
         difficulty,
         noteCount,
@@ -87,6 +89,7 @@ export async function handler(
       ranked: beatmapPage.beatmaps?.ranked,
       beatmapFile: beatmapPage.beatmaps?.beatmapFile,
       image: beatmapPage.beatmaps?.image,
+      imageLarge: beatmapPage.beatmaps?.imageLarge,
       starRating: beatmapPage.beatmaps?.starRating,
       owner: beatmapPage.owner,
       ownerUsername: beatmapPage.profiles?.username,

package/api/updateBeatmapPage.ts

@@ -7,9 +7,9 @@ export const Schema = {
   input: z.strictObject({
     session: z.string(),
     id: z.number(),
-    beatmapHash: z.string(),
-    tags: z.string(),
-    description: z.string(),
+    beatmapHash: z.string().optional(),
+    tags: z.string().optional(),
+    description: z.string().optional(),
   }),
   output: z.strictObject({
     error: z.string().optional(),
@@ -47,14 +47,17 @@ export async function handler({
     .eq("id", id)
     .single();
 
+  if (!userData) return NextResponse.json({ error: "No user." });
+
   let { data: beatmapData, error: bmPageError } = await supabase
     .from("beatmaps")
     .select("*")
-    .eq("beatmapHash", beatmapHash)
+    .eq("beatmapHash", beatmapHash || "")
     .single();
 
-  if (!userData) return NextResponse.json({ error: "No user." });
-  if (!beatmapData) return NextResponse.json({ error: "No beatmap." });
+  if (!beatmapData && beatmapHash) {
+    return NextResponse.json({ error: "No beatmap." });
+  }
 
   if (userData.id !== pageData?.owner)
     return NextResponse.json({ error: "Non-authz user." });
@@ -62,19 +65,24 @@ export async function handler({
   if (pageData?.status !== "UNRANKED")
     return NextResponse.json({ error: "Only unranked maps can be updated" });
 
+  const upsertPayload = {
+    id,
+    genre: "",
+    status: "UNRANKED",
+    owner: userData.id,
+    description: description ? description : pageData.description,
+    tags: tags ? tags : pageData.tags,
+  };
+
+  if (beatmapHash && beatmapData) {
+    upsertPayload["title"] = beatmapData.title;
+    upsertPayload["latestBeatmapHash"] = beatmapHash;
+    upsertPayload["nominations"] = [];
+  }
+
   const upserted = await supabase
     .from("beatmapPages")
-    .upsert({
-      id,
-      latestBeatmapHash: beatmapHash,
-      genre: "",
-      title: beatmapData.title,
-      status: "UNRANKED",
-      owner: userData.id,
-      description,
-      tags,
-      nominations: [],
-    })
+    .upsert(upsertPayload)
     .select("*")
     .single();
 

package/index.ts

@@ -198,6 +198,7 @@ export const Schema = {
         ranked: z.boolean().nullable().optional(),
         beatmapFile: z.string().nullable().optional(),
         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(),
@@ -593,9 +594,9 @@ export const Schema = {
   input: z.strictObject({
     session: z.string(),
     id: z.number(),
-    beatmapHash: z.string(),
-    tags: z.string(),
-    description: z.string(),
+    beatmapHash: z.string().optional(),
+    tags: z.string().optional(),
+    description: z.string().optional(),
   }),
   output: z.strictObject({
     error: z.string().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "149.0.0",
+  "version": "151.0.0",
   "main": "index.ts",
   "scripts": {
     "update": "bun ./scripts/update.ts",
@@ -38,7 +38,7 @@
     "osu-standard-stable": "^5.0.0",
     "sharp": "^0.33.5",
     "simple-git": "^3.25.0",
-    "supabase": "^1.204.3",
+    "supabase": "^1.207.9",
     "tsx": "^4.17.0",
     "utf-8-validate": "^6.0.4",
     "zod": "^3.23.8"

package/types/database.ts

@@ -109,6 +109,7 @@ export type Database = {
           created_at: string
           difficulty: number | null
           image: string | null
+          imageLarge: string | null
           length: number | null
           noteCount: number | null
           playcount: number | null
@@ -122,6 +123,7 @@ export type Database = {
           created_at?: string
           difficulty?: number | null
           image?: string | null
+          imageLarge?: string | null
           length?: number | null
           noteCount?: number | null
           playcount?: number | null
@@ -135,6 +137,7 @@ export type Database = {
           created_at?: string
           difficulty?: number | null
           image?: string | null
+          imageLarge?: string | null
           length?: number | null
           noteCount?: number | null
           playcount?: number | null
@@ -202,15 +205,7 @@ export type Database = {
           username?: string | null
           verified?: boolean | null
         }
-        Relationships: [
-          {
-            foreignKeyName: "profiles_uid_fkey"
-            columns: ["uid"]
-            isOneToOne: true
-            referencedRelation: "users"
-            referencedColumns: ["id"]
-          },
-        ]
+        Relationships: []
       }
       scores: {
         Row: {
@@ -363,3 +358,18 @@ export type Enums<
   : PublicEnumNameOrOptions extends keyof PublicSchema["Enums"]
     ? PublicSchema["Enums"][PublicEnumNameOrOptions]
     : never
+
+export type CompositeTypes<
+  PublicCompositeTypeNameOrOptions extends
+    | keyof PublicSchema["CompositeTypes"]
+    | { schema: keyof Database },
+  CompositeTypeName extends PublicCompositeTypeNameOrOptions extends {
+    schema: keyof Database
+  }
+    ? keyof Database[PublicCompositeTypeNameOrOptions["schema"]]["CompositeTypes"]
+    : never = never,
+> = PublicCompositeTypeNameOrOptions extends { schema: keyof Database }
+  ? Database[PublicCompositeTypeNameOrOptions["schema"]]["CompositeTypes"][CompositeTypeName]
+  : PublicCompositeTypeNameOrOptions extends keyof PublicSchema["CompositeTypes"]
+    ? PublicSchema["CompositeTypes"][PublicCompositeTypeNameOrOptions]
+    : never

package/utils/star-calc/index.ts

@@ -1,4 +1,4 @@
-import { BeatmapDecoder } from "osu-parsers";
+import { BeatmapDecoder, BeatmapEncoder } from "osu-parsers";
 import { StandardRuleset } from "osu-standard-stable";
 import { sampleMap } from "./osuUtils";
 import { SSPMParsedMap } from "./sspmParser";
@@ -18,9 +18,6 @@ export function calculatePerformancePoints(
 }
 
 export function rateMap(map: SSPMParsedMap) {
-  const decoder = new BeatmapDecoder();
-  const beatmap1 = decoder.decodeFromString(sampleMap);
-
   let notes = map.markers
     .filter((marker) => marker.type === 0)
     .map((marker) => ({
@@ -29,44 +26,52 @@ export function rateMap(map: SSPMParsedMap) {
       y: marker.data["field0"].y,
     }));
 
-  notes = notes.sort((a, b) => a.time - b.time);
-
-  for (const note of notes) {
-    const hittable = beatmap1.hitObjects[0].clone();
-    hittable.startX = Math.round((note.x / 2) * 100);
-    hittable.startY = Math.round((note.y / 2) * 100);
-    hittable.startTime = note.time;
-    beatmap1.hitObjects.push(hittable);
-  }
-  const ruleset = new StandardRuleset();
-  const mods = ruleset.createModCombination("RX");
-  const difficultyCalculator = ruleset.createDifficultyCalculator(beatmap1);
-  const difficultyAttributes = difficultyCalculator.calculateWithMods(mods);
-  return difficultyAttributes.starRating;
+  return rate(notes);
 }
 
 export function rateMapOld(map: SSPMMap) {
-  const decoder = new BeatmapDecoder();
-  const beatmap1 = decoder.decodeFromString(sampleMap);
-
   let notes = map.notes.map((marker) => ({
     time: marker.position,
     x: marker.x,
     y: marker.y,
   }));
 
+  return rate(notes);
+}
+
+export function rate(
+  notes: {
+    time: number;
+    x: number;
+    y: number;
+  }[]
+) {
   notes = notes.sort((a, b) => a.time - b.time);
+  const decoder = new BeatmapDecoder();
+  const encoder = new BeatmapEncoder();
+  const beatmap1 = decoder.decodeFromString(sampleMap);
+  let i = 0;
+  while (i < notes.length - 1) {
+    const note = notes[i];
+    const nextNote = notes[i + 1];
+    if (distance(note.x, note.y, nextNote.x, nextNote.y) < 1.25) {
+      notes.splice(i + 1, 1);
+      continue;
+    }
 
-  for (const note of notes) {
     const hittable = beatmap1.hitObjects[0].clone();
     hittable.startX = Math.round((note.x / 2) * 100);
     hittable.startY = Math.round((note.y / 2) * 100);
     hittable.startTime = note.time;
     beatmap1.hitObjects.push(hittable);
+    i++;
   }
   const ruleset = new StandardRuleset();
   const mods = ruleset.createModCombination("RX");
   const difficultyCalculator = ruleset.createDifficultyCalculator(beatmap1);
   const difficultyAttributes = difficultyCalculator.calculateWithMods(mods);
+  encoder.encodeToPath("./map.osu", beatmap1);
   return difficultyAttributes.starRating;
 }
+
+const distance = (x1, y1, x2, y2) => Math.hypot(x2 - x1, y2 - y1);