rhythia-api 110.0.0 → 112.0.0

package/api/createBeatmap.ts

@@ -2,6 +2,19 @@ import { NextResponse } from "next/server";
 import z from "zod";
 import { protectedApi, validUser } from "../utils/requestUtils";
 import { SSPMParser } from "../utils/star-calc/sspmParser";
+import { supabase } from "../utils/supabase";
+import { createHash } from "crypto";
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { rateMap } from "../utils/star-calc";
+
+const s3Client = new S3Client({
+  region: "auto",
+  endpoint: "https://s3.eu-central-003.backblazeb2.com",
+  credentials: {
+    secretAccessKey: "K0039mm4iKsteQOXpZSzf0+VDzuH89U",
+    accessKeyId: "003c245e893e8060000000001",
+  },
+});
 
 export const Schema = {
   input: z.strictObject({
@@ -38,7 +51,33 @@ export async function handler({
   const parser = new SSPMParser(Buffer.from(bytes));
 
   const parsedData = parser.parse();
+  let sum = createHash("sha1");
+  sum.update(Buffer.from(bytes));
+  const digested = sum.digest("hex");
+  const imgkey = `beatmap-img-${Date.now()}-${digested}`;
+  const command = new PutObjectCommand({
+    Bucket: "rhthia-avatars",
+    Key: imgkey,
+    Body: parsedData.cover,
+    ContentType: "image/jpeg",
+  });
+
+  await s3Client.send(command);
+  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,
+    beatmapFile: url,
+    image: `https://rhthia-avatars.s3.eu-central-003.backblazeb2.com/${imgkey}`,
+    starRating: rateMap(parsedData),
+  });
 
-  console.log(parsedData);
-  return NextResponse.json({});
+  if (upserted.error?.message.length) {
+    return NextResponse.json({ error: upserted.error.message });
+  }
+  return NextResponse.json({ hash: digested });
 }

package/api/getBeatmapPage.ts

@@ -0,0 +1,91 @@
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    id: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    beatmap: z
+      .object({
+        playcount: z.number().nullable().optional(),
+        created_at: z.string().nullable().optional(),
+        difficulty: z.number().nullable().optional(),
+        noteCount: z.number().nullable().optional(),
+        length: z.number().nullable().optional(),
+        title: z.string().nullable().optional(),
+        ranked: z.boolean().nullable().optional(),
+        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(),
+      })
+      .optional(),
+  }),
+};
+
+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"],
+  req: Request
+): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  let { data: beatmapPage, error: errorlast } = await supabase
+    .from("beatmapPages")
+    .select(
+      `
+      *,
+      beatmaps (
+        created_at,
+        playcount,
+        length,
+        ranked,
+        beatmapFile,
+        image,
+        starRating,
+        difficulty,
+        noteCount,
+        title
+      ),
+      profiles (
+        username,
+        avatar_url
+      )
+    `
+    )
+    .eq("id", data.id)
+    .single();
+
+  if (!beatmapPage) return NextResponse.json({});
+
+  return NextResponse.json({
+    beatmap: {
+      playcount: beatmapPage.beatmaps?.playcount,
+      created_at: beatmapPage.created_at,
+      difficulty: beatmapPage.beatmaps?.difficulty,
+      noteCount: beatmapPage.beatmaps?.noteCount,
+      length: beatmapPage.beatmaps?.length,
+      title: beatmapPage.beatmaps?.title,
+      ranked: beatmapPage.beatmaps?.ranked,
+      beatmapFile: beatmapPage.beatmaps?.beatmapFile,
+      image: beatmapPage.beatmaps?.image,
+      starRating: beatmapPage.beatmaps?.starRating,
+      owner: beatmapPage.owner,
+      ownerUsername: beatmapPage.profiles?.username,
+      ownerAvatar: beatmapPage.profiles?.avatar_url,
+    },
+  });
+}

package/api/getMapUploadUrl.ts

@@ -56,7 +56,7 @@ export async function handler({
     });
   }
 
-  const key = `beatmap-${Date.now()}-${user.id}`;
+  const key = `beatmap-${Date.now()}-${user.id}.sspm`;
   const command = new PutObjectCommand({
     Bucket: "rhthia-avatars",
     Key: key,

package/api/updateBeatmapPage.ts

@@ -57,7 +57,7 @@ export async function handler({
     .select("*")
     .single();
 
-  if (upserted.error) {
+  if (upserted.error?.message.length) {
     return NextResponse.json({ error: upserted.error.message });
   }
   return NextResponse.json({});

package/index.ts

@@ -25,6 +25,11 @@ import { Schema as GetAvatarUploadUrl } from "./api/getAvatarUploadUrl"
 export { Schema as SchemaGetAvatarUploadUrl } from "./api/getAvatarUploadUrl"
 export const getAvatarUploadUrl = handleApi({url:"/api/getAvatarUploadUrl",...GetAvatarUploadUrl})
 
+// ./api/getBeatmapPage.ts API
+import { Schema as GetBeatmapPage } from "./api/getBeatmapPage"
+export { Schema as SchemaGetBeatmapPage } from "./api/getBeatmapPage"
+export const getBeatmapPage = handleApi({url:"/api/getBeatmapPage",...GetBeatmapPage})
+
 // ./api/getLeaderboard.ts API
 import { Schema as GetLeaderboard } from "./api/getLeaderboard"
 export { Schema as SchemaGetLeaderboard } from "./api/getLeaderboard"

package/package.json

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

package/types/database.ts

@@ -54,8 +54,10 @@ export type Database = {
           image: string | null
           length: number | null
           noteCount: number | null
+          pageId: number | null
           playcount: number | null
           ranked: boolean | null
+          starRating: number | null
           title: string | null
         }
         Insert: {
@@ -66,8 +68,10 @@ export type Database = {
           image?: string | null
           length?: number | null
           noteCount?: number | null
+          pageId?: number | null
           playcount?: number | null
           ranked?: boolean | null
+          starRating?: number | null
           title?: string | null
         }
         Update: {
@@ -78,11 +82,21 @@ export type Database = {
           image?: string | null
           length?: number | null
           noteCount?: number | null
+          pageId?: number | null
           playcount?: number | null
           ranked?: boolean | null
+          starRating?: number | null
           title?: string | null
         }
-        Relationships: []
+        Relationships: [
+          {
+            foreignKeyName: "beatmaps_pageId_fkey"
+            columns: ["pageId"]
+            isOneToOne: false
+            referencedRelation: "beatmapPages"
+            referencedColumns: ["id"]
+          },
+        ]
       }
       profiles: {
         Row: {