rhythia-api 241.0.0 → 243.0.0

package/api/createBeatmap.ts

@@ -3,36 +3,10 @@ import z from "zod";
 import { protectedApi, validUser } from "../utils/requestUtils";
 import { SSPMParser } from "../utils/star-calc/sspmParser";
 import { supabase } from "../utils/supabase";
-import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
 import { rateMap } from "../utils/star-calc";
 import { getUserBySession } from "../utils/getUserBySession";
 import { User } from "@supabase/supabase-js";
-
-const s3Client = new S3Client({
-  region: "auto",
-  endpoint: "https://s3.eu-central-003.backblazeb2.com",
-  credentials: {
-    secretAccessKey: process.env.SECRET_BUCKET || "",
-    accessKeyId: process.env.ACCESS_BUCKET || "",
-  },
-  requestChecksumCalculation: "WHEN_REQUIRED",
-});
-
-s3Client.middlewareStack.add(
-  (next) =>
-    async (args): Promise<any> => {
-      const request = args.request as RequestInit;
-      const headers = request.headers as Record<string, string>;
-      delete headers["x-amz-checksum-crc32"];
-      delete headers["x-amz-checksum-crc32c"];
-      delete headers["x-amz-checksum-sha1"];
-      delete headers["x-amz-checksum-sha256"];
-      request.headers = headers;
-
-      return next(args);
-    },
-  { step: "build", name: "customHeaders" }
-);
+import { putStaticObject, readStaticObject } from "../utils/beatmapFiles";
 
 function getCoverContentType(cover: Uint8Array) {
   if (
@@ -105,11 +79,58 @@ export async function handler({
   if (!url.startsWith(`https://static.rhythia.com/`))
     return NextResponse.json({ error: "Invalid url" });
 
-  const request = await fetch(url);
-  const bytes = await request.arrayBuffer();
-  const parser = new SSPMParser(Buffer.from(bytes));
+  let parsedData: ReturnType<SSPMParser["parse"]> | undefined;
+  let parseError: unknown;
+
+  for (let attempt = 0; attempt < 4; attempt++) {
+    try {
+      const { object, objectKey, bytes } = await readStaticObject(url);
+      const isSSPM = bytes.subarray(0, 4).toString("hex") === "53532b6d";
+      console.log("createBeatmap object fetch result", {
+        attempt: attempt + 1,
+        url,
+        objectKey,
+        contentType: object.ContentType,
+        contentLength: object.ContentLength,
+        byteLength: bytes.length,
+        firstBytesHex: bytes.subarray(0, 16).toString("hex"),
+        firstBytesText: bytes
+          .subarray(0, 16)
+          .toString("utf8")
+          .replace(/[^\x20-\x7e]/g, "."),
+        bodyPreview:
+          !isSSPM && bytes.length <= 512
+            ? bytes.toString("utf8").replace(/[^\x09\x0a\x0d\x20-\x7e]/g, ".")
+            : undefined,
+        eTag: object.ETag,
+        versionId: object.VersionId,
+      });
+
+      const parser = new SSPMParser(bytes);
+
+      parsedData = parser.parse();
+      console.log("createBeatmap parsed SSPM", {
+        attempt: attempt + 1,
+        mapID: parsedData.strings.mapID,
+        noteCount: parsedData.metadata.noteCount,
+        markerCount: parsedData.metadata.markerCount,
+      });
+      break;
+    } catch (error) {
+      parseError = error;
+      console.log("createBeatmap parse failed", {
+        attempt: attempt + 1,
+        error: error?.toString?.() || String(error),
+      });
+
+      if (attempt < 3) {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+    }
+  }
+
+  if (!parsedData) throw parseError;
 
-  const parsedData = parser.parse();
   const digested = parsedData.strings.mapID;
 
   const user = (await getUserBySession(session)) as User;
@@ -169,14 +190,11 @@ export async function handler({
   const cover = parsedData.cover || Buffer.from([]);
   const coverContentType = getCoverContentType(cover);
 
-  await s3Client.send(
-    new PutObjectCommand({
-      Bucket: "rhthia-avatars",
-      Key: imgkey,
-      Body: cover,
-      ContentType: coverContentType,
-    })
-  );
+  await putStaticObject({
+    key: imgkey,
+    body: cover,
+    contentType: coverContentType,
+  });
 
   const markers = parsedData.markers.sort((a, b) => a.position - b.position);
 

package/api/editProfile.ts

@@ -4,15 +4,12 @@ import { Database } from "../types/database";
 import { protectedApi, validUser } from "../utils/requestUtils";
 import { supabase } from "../utils/supabase";
 import { getUserBySession } from "../utils/getUserBySession";
-import { COUNTRY_LIST } from "../utils/countryList";
 import { User } from "@supabase/supabase-js";
-import validator from "validator";
-import removeZeroWidth from "zero-width";
+import { normalizeProfileUpdateData } from "../utils/profileUpdateValidation";
 
 const USERNAME_CHANGE_COOLDOWN_ERROR =
   "Username can only be changed once every 6 months";
 const FLAG_CHANGE_ERROR = "Flag can only be changed once";
-const countryCodes = new Set(COUNTRY_LIST);
 
 function getNextUsernameChangeAt(
   lastChangedAt: string | null | undefined
@@ -71,59 +68,10 @@ export async function POST(request: Request): Promise<NextResponse> {
 export async function handler(
   data: (typeof Schema)["input"]["_type"]
 ): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
-  if (data.data.username !== undefined) {
-    if (data.data.username.length < 3) {
-      return NextResponse.json(
-        {
-          error: "Username must be at least 3 characters long",
-        },
-        { status: 404 }
-      );
-    }
-
-    if (data.data.username.length > 20) {
-      return NextResponse.json(
-        {
-          error: "Username too long.",
-        },
-        { status: 404 }
-      );
-    }
-
-    if (!/^[a-z0-9]+$/i.test(data.data.username)) {
-      return NextResponse.json(
-        {
-          error: "Username can only contain letters (a-z) and numbers (0-9)",
-        },
-        { status: 404 }
-      );
-    }
-  }
-
-  if (validator.trim(data.data.username || "") !== (data.data.username || "")) {
-    return NextResponse.json(
-      {
-        error: "Username can't start or end with spaces.",
-      },
-      { status: 404 }
-    );
-  }
-
-  data.data.username = removeZeroWidth(data.data.username || "");
-
-  if (data.data.flag !== undefined) {
-    const normalizedFlag = validator.trim(data.data.flag).toUpperCase();
-
-    if (!countryCodes.has(normalizedFlag as (typeof COUNTRY_LIST)[number])) {
-      return NextResponse.json(
-        {
-          error: "Flag must be a valid country code.",
-        },
-        { status: 404 }
-      );
-    }
+  const validationError = normalizeProfileUpdateData(data.data);
 
-    data.data.flag = normalizedFlag;
+  if (validationError) {
+    return NextResponse.json({ error: validationError }, { status: 404 });
   }
 
   const user = (await getUserBySession(data.session)) as User;

package/api/editProfileFriend.ts

@@ -0,0 +1,122 @@
+import { NextResponse } from "../utils/response";
+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 friendStateSchema = z.enum(["none", "added", "mutual"]);
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    profileId: z.number(),
+    action: z.enum(["add", "remove"]),
+  }),
+  output: z.strictObject({
+    error: z.string().optional(),
+    friend_count: z.number().optional(),
+    friend_state: friendStateSchema.optional(),
+  }),
+};
+
+async function getFriendState(viewerProfileId: number, profileId: number) {
+  const [{ count: addedCount }, { count: mutualCount }] = await Promise.all([
+    supabase
+      .from("profileFriends")
+      .select("*", { count: "exact", head: true })
+      .eq("profile_id", viewerProfileId)
+      .eq("friend_id", profileId),
+    supabase
+      .from("profileFriends")
+      .select("*", { count: "exact", head: true })
+      .eq("profile_id", profileId)
+      .eq("friend_id", viewerProfileId),
+  ]);
+
+  if (!addedCount) {
+    return "none";
+  }
+
+  return mutualCount ? "mutual" : "added";
+}
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler({
+  session,
+  profileId,
+  action,
+}: (typeof Schema)["input"]["_type"]): Promise<
+  NextResponse<(typeof Schema)["output"]["_type"]>
+> {
+  const user = (await getUserBySession(session)) as User;
+
+  const { data: viewerProfile } = await supabase
+    .from("profiles")
+    .select("id")
+    .eq("uid", user.id)
+    .single();
+
+  if (!viewerProfile) {
+    return NextResponse.json({ error: "Can't find user" });
+  }
+
+  if (viewerProfile.id === profileId) {
+    return NextResponse.json({ error: "You can't friend yourself." });
+  }
+
+  const { data: targetProfile } = await supabase
+    .from("profiles")
+    .select("id")
+    .eq("id", profileId)
+    .single();
+
+  if (!targetProfile) {
+    return NextResponse.json({ error: "Player not found." });
+  }
+
+  const relation = {
+    profile_id: viewerProfile.id,
+    friend_id: targetProfile.id,
+  };
+
+  const mutation =
+    action === "add"
+      ? await supabase
+          .from("profileFriends")
+          .upsert(relation, {
+            onConflict: "profile_id,friend_id",
+            ignoreDuplicates: true,
+          })
+      : await supabase
+          .from("profileFriends")
+          .delete()
+          .eq("profile_id", relation.profile_id)
+          .eq("friend_id", relation.friend_id);
+
+  if (mutation.error) {
+    return NextResponse.json({ error: mutation.error.message });
+  }
+
+  const [friendCount, friendState] = await Promise.all([
+    supabase
+      .from("profileFriends")
+      .select("*", { count: "exact", head: true })
+      .eq("friend_id", targetProfile.id)
+      .then((result) => result.count || 0),
+    getFriendState(viewerProfile.id, targetProfile.id),
+  ]);
+
+  return NextResponse.json({
+    friend_count: friendCount,
+    friend_state: friendState,
+  });
+}