rhythia-api 242.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,70 +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) {
-    data.data.username = removeZeroWidth(data.data.username);
+  const validationError = normalizeProfileUpdateData(data.data);
 
-    if (validator.trim(data.data.username) !== data.data.username) {
-      return NextResponse.json(
-        {
-          error: "Username can't start or end with spaces.",
-        },
-        { status: 404 }
-      );
-    }
-
-    if (data.data.username.length < 2) {
-      return NextResponse.json(
-        {
-          error: "Username must be at least 2 characters long",
-        },
-        { status: 404 }
-      );
-    }
-
-    if (data.data.username.length > 16) {
-      return NextResponse.json(
-        {
-          error: "Username must be 16 characters or fewer.",
-        },
-        { status: 404 }
-      );
-    }
-
-    if (!/^[A-Za-z0-9._]+$/.test(data.data.username)) {
-      return NextResponse.json(
-        {
-          error:
-            "Username can only contain English letters (a-z), numbers (0-9), and up to one '_' or '.'",
-        },
-        { status: 404 }
-      );
-    }
-
-    const specialCharacters = data.data.username.match(/[._]/g) ?? [];
-    if (specialCharacters.length > 1) {
-      return NextResponse.json(
-        {
-          error: "Username can contain at most one '_' or one '.'",
-        },
-        { status: 404 }
-      );
-    }
-  }
-
-  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 }
-      );
-    }
-
-    data.data.flag = normalizedFlag;
+  if (validationError) {
+    return NextResponse.json({ error: validationError }, { status: 404 });
   }
 
   const user = (await getUserBySession(data.session)) as User;