rhythia-api 242.0.0 → 243.0.0

package/utils/beatmapFiles.ts

@@ -0,0 +1,102 @@
+import {
+  GetObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from "@aws-sdk/client-s3";
+import { existsSync } from "node:fs";
+
+if (existsSync(".env")) process.loadEnvFile?.(".env");
+if (existsSync(".env.local")) process.loadEnvFile?.(".env.local");
+
+export const beatmapBucket = "rhthia-avatars";
+
+export const beatmapS3Client = 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",
+});
+
+beatmapS3Client.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: "stripBackblazeChecksumHeaders" }
+);
+
+export function getStaticObjectKey(url: string) {
+  return decodeURIComponent(new URL(url).pathname.slice(1));
+}
+
+export async function readStaticObject(url: string) {
+  if (
+    !url.startsWith("https://static.rhythia.com/") ||
+    !process.env.ACCESS_BUCKET ||
+    !process.env.SECRET_BUCKET
+  ) {
+    const response = await fetch(url);
+    const bytes = Buffer.from(await response.arrayBuffer());
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch beatmap file: ${response.status} ${response.statusText}`
+      );
+    }
+
+    return {
+      object: {
+        ContentType: response.headers.get("content-type") || undefined,
+        ContentLength: Number(response.headers.get("content-length")) || bytes.length,
+        ETag: response.headers.get("etag") || undefined,
+      },
+      objectKey: getStaticObjectKey(url),
+      bytes,
+    };
+  }
+
+  const objectKey = getStaticObjectKey(url);
+  const object = await beatmapS3Client.send(
+    new GetObjectCommand({
+      Bucket: beatmapBucket,
+      Key: objectKey,
+    })
+  );
+
+  return {
+    object,
+    objectKey,
+    bytes: Buffer.from(await object.Body!.transformToByteArray()),
+  };
+}
+
+export async function putStaticObject({
+  key,
+  body,
+  contentType,
+}: {
+  key: string;
+  body: Uint8Array | Buffer;
+  contentType: string;
+}) {
+  return beatmapS3Client.send(
+    new PutObjectCommand({
+      Bucket: beatmapBucket,
+      Key: key,
+      Body: body,
+      ContentType: contentType,
+    })
+  );
+}

package/utils/beatmapHash.ts

@@ -0,0 +1,336 @@
+import { createHash } from "node:crypto";
+import { SSPMParser, type SSPMParsedMap } from "./star-calc/sspmParser.ts";
+import { V1SSPMParser, type SSPMMap } from "./star-calc/sspmv1Parser.ts";
+
+const IntrosortSizeThreshold = 16;
+const GeneralScientificLowerExponentDotNet = -5;
+const DecimalTieTolerance = Number.EPSILON * 4;
+
+type Marker = SSPMParsedMap["markers"][number];
+
+function formatSingle(value: number) {
+  value = Math.fround(value);
+
+  for (let precision = 1; precision <= 9; precision++) {
+    const rounded = Number(value.toPrecision(precision));
+    const formatted = formatGeneralDotNet(
+      breakDecimalTieDotNet(value, rounded, precision)
+    );
+
+    if (Math.fround(Number(formatted)) === value) {
+      return formatted;
+    }
+  }
+
+  return formatGeneralDotNet(value);
+}
+
+function formatGeneralDotNet(value: number) {
+  if (value === 0) {
+    return "0";
+  }
+
+  const formatted = value.toString();
+  const exponent = getDecimalExponent(value);
+
+  if (
+    formatted.includes("e") ||
+    exponent <= GeneralScientificLowerExponentDotNet
+  ) {
+    return formatExponential(value, getSignificantDigitCount(formatted));
+  }
+
+  return formatted;
+}
+
+function getDecimalExponent(value: number) {
+  return Math.floor(Math.log10(Math.abs(value)));
+}
+
+function getSignificantDigitCount(value: string) {
+  const [mantissa] = value.toLowerCase().split("e");
+  const digits = mantissa!.replace("-", "").replace(".", "").replace(/^0+/, "");
+  return Math.max(digits.length, 1);
+}
+
+function formatExponential(value: number, significantDigitCount: number) {
+  const [mantissa, exponent] = value
+    .toExponential(significantDigitCount - 1)
+    .split("e");
+  const exponentValue = Number(exponent);
+  const exponentSign = exponentValue < 0 ? "-" : "+";
+  const exponentDigits = Math.abs(exponentValue).toString().padStart(2, "0");
+  const normalizedMantissa = mantissa!
+    .replace(/(\.\d*?)0+$/, "$1")
+    .replace(/\.$/, "");
+
+  return `${normalizedMantissa}E${exponentSign}${exponentDigits}`;
+}
+
+function breakDecimalTieDotNet(
+  value: number,
+  rounded: number,
+  precision: number
+) {
+  if (rounded === value || Math.fround(rounded) !== value) {
+    return rounded;
+  }
+
+  const exponent = getDecimalExponent(rounded);
+  const step = 10 ** (exponent - precision + 1);
+  const alternate = Number(
+    (rounded > value ? rounded - step : rounded + step).toPrecision(precision)
+  );
+
+  if (alternate === rounded || Math.fround(alternate) !== value) {
+    return rounded;
+  }
+
+  const roundedDistance = Math.abs(value - rounded);
+  const alternateDistance = Math.abs(value - alternate);
+  const tolerance =
+    DecimalTieTolerance *
+    Math.max(1, Math.abs(value), Math.abs(rounded), Math.abs(alternate));
+
+  if (alternateDistance + tolerance < roundedDistance) {
+    return alternate;
+  }
+
+  if (roundedDistance + tolerance < alternateDistance) {
+    return rounded;
+  }
+
+  return hasEvenLastSignificantDigit(alternate, precision)
+    ? alternate
+    : rounded;
+}
+
+function hasEvenLastSignificantDigit(value: number, precision: number) {
+  const [mantissa] = Math.abs(value).toPrecision(precision).split("e");
+  const digits = mantissa!.replace(".", "").replace(/^0+/, "");
+  const lastDigit = Number(digits.at(-1));
+
+  return lastDigit % 2 === 0;
+}
+
+function compareMarkerPosition(a: Marker, b: Marker) {
+  return a.position - b.position;
+}
+
+function swap(items: Marker[], left: number, right: number) {
+  const temp = items[left]!;
+  items[left] = items[right]!;
+  items[right] = temp;
+}
+
+function swapIfGreater(items: Marker[], left: number, right: number) {
+  if (
+    left !== right &&
+    compareMarkerPosition(items[left]!, items[right]!) > 0
+  ) {
+    swap(items, left, right);
+  }
+}
+
+function insertionSort(items: Marker[], start: number, length: number) {
+  for (let i = start; i < start + length - 1; i++) {
+    const value = items[i + 1]!;
+    let j = i;
+
+    while (j >= start && compareMarkerPosition(value, items[j]!) < 0) {
+      items[j + 1] = items[j]!;
+      j--;
+    }
+
+    items[j + 1] = value;
+  }
+}
+
+function downHeap(
+  items: Marker[],
+  start: number,
+  index: number,
+  heapSize: number
+) {
+  const value = items[start + index - 1]!;
+  let child: number;
+
+  while ((child = 2 * index) <= heapSize) {
+    if (
+      child < heapSize &&
+      compareMarkerPosition(items[start + child - 1]!, items[start + child]!) <
+        0
+    ) {
+      child++;
+    }
+
+    if (compareMarkerPosition(value, items[start + child - 1]!) >= 0) {
+      break;
+    }
+
+    items[start + index - 1] = items[start + child - 1]!;
+    index = child;
+  }
+
+  items[start + index - 1] = value;
+}
+
+function heapSort(items: Marker[], start: number, length: number) {
+  for (let i = Math.floor(length / 2); i >= 1; i--) {
+    downHeap(items, start, i, length);
+  }
+
+  for (let i = length; i > 1; i--) {
+    swap(items, start, start + i - 1);
+    downHeap(items, start, 1, i - 1);
+  }
+}
+
+function pickPivotAndPartition(items: Marker[], start: number, length: number) {
+  const high = start + length - 1;
+  const middle = start + ((high - start) >> 1);
+
+  swapIfGreater(items, start, middle);
+  swapIfGreater(items, start, high);
+  swapIfGreater(items, middle, high);
+
+  const pivot = items[middle]!;
+  swap(items, middle, high - 1);
+
+  let left = start;
+  let right = high - 1;
+
+  while (left < right) {
+    while (compareMarkerPosition(items[++left]!, pivot) < 0) {}
+    while (compareMarkerPosition(pivot, items[--right]!) < 0) {}
+
+    if (left >= right) {
+      break;
+    }
+
+    swap(items, left, right);
+  }
+
+  if (left !== high - 1) {
+    swap(items, left, high - 1);
+  }
+
+  return left;
+}
+
+function introSort(
+  items: Marker[],
+  start: number,
+  length: number,
+  depthLimit: number
+) {
+  let partitionSize = length;
+
+  while (partitionSize > 1) {
+    if (partitionSize <= IntrosortSizeThreshold) {
+      if (partitionSize === 2) {
+        swapIfGreater(items, start, start + 1);
+        return;
+      }
+
+      if (partitionSize === 3) {
+        swapIfGreater(items, start, start + 1);
+        swapIfGreater(items, start, start + 2);
+        swapIfGreater(items, start + 1, start + 2);
+        return;
+      }
+
+      insertionSort(items, start, partitionSize);
+      return;
+    }
+
+    if (depthLimit === 0) {
+      heapSort(items, start, partitionSize);
+      return;
+    }
+
+    depthLimit--;
+    const pivot = pickPivotAndPartition(items, start, partitionSize);
+    introSort(
+      items,
+      pivot + 1,
+      start + partitionSize - (pivot + 1),
+      depthLimit
+    );
+    partitionSize = pivot - start;
+  }
+}
+
+function sortByPositionDotNet(markers: Marker[]) {
+  const result = [...markers];
+
+  if (result.length > 1) {
+    const depthLimit = 2 * (Math.floor(Math.log2(result.length)) + 1);
+    introSort(result, 0, result.length, depthLimit);
+  }
+
+  return result;
+}
+
+export function computeBeatmapHash(map: SSPMParsedMap) {
+  const noteType = Math.max(
+    map.markerDefinitions.findIndex((x) => x.id === "ssp_note"),
+    0
+  );
+  const customDifficultyName =
+    map.customData.fields.find((x) => x.id === "difficulty_name")?.value ?? "";
+
+  const hashString =
+    map.strings.mapName +
+    map.strings.mapName +
+    map.strings.mappers.join(",") +
+    map.metadata.lastMarkerPos +
+    sortByPositionDotNet(map.markers.filter((x) => x.type === noteType))
+      .map(
+        (x) =>
+          x.position +
+          formatSingle(x.data.position.x) +
+          formatSingle(x.data.position.y)
+      )
+      .join(",") +
+    map.metadata.difficulty +
+    customDifficultyName;
+
+  return createHash("sha256").update(hashString, "utf16le").digest("hex");
+}
+
+export function computeV1BeatmapHash(map: SSPMMap) {
+  const hashString =
+    map.name +
+    map.name +
+    map.creator
+      .split(/[&,]/)
+      .map((x) => x.trim())
+      .join(",") +
+    map.lastNotePosition +
+    map.notes
+      .map(
+        (x) =>
+          x.position +
+          formatSingle(x.x) +
+          formatSingle(x.y)
+      )
+      .join(",") +
+    map.difficulty;
+
+  return createHash("sha256").update(hashString, "utf16le").digest("hex");
+}
+
+export function computeBeatmapHashFromBytes(bytes: Buffer) {
+  const version = bytes.readUInt16LE(4);
+
+  if (version === 1) {
+    return computeV1BeatmapHash(new V1SSPMParser(bytes).parse());
+  }
+
+  if (version === 2) {
+    return computeBeatmapHash(new SSPMParser(bytes).parse());
+  }
+
+  throw new Error(`Invalid SSPM version: ${version}`);
+}

package/utils/beatmapTopScores.ts

@@ -1,84 +1,68 @@
-import { Database } from "../types/database";
-import { getActiveProfileIdSet } from "./activityStatus";
-import { supabase } from "./supabase";
-
-type BeatmapTopScoreRow =
-  Database["public"]["Functions"]["get_top_scores_for_beatmap3"]["Returns"][number];
-
-export type BeatmapTopScore = {
-  id: number;
-  awarded_sp: number | null;
-  created_at: string;
-  misses: number | null;
-  mods: Record<string, unknown>;
-  passed: boolean | null;
-  songId: string | null;
-  speed: number | null;
-  spin: boolean;
-  userId: number | null;
-  username: string | null;
-  avatar_url: string | null;
-  accuracy: number | null;
-};
-
-type GetBeatmapTopScoresResult = {
-  error?: string;
-  scores: BeatmapTopScore[];
-};
-
-function mapBeatmapTopScore(score: BeatmapTopScoreRow): BeatmapTopScore {
-  return {
-    id: score.id,
-    awarded_sp: score.awarded_sp,
-    created_at: score.created_at,
-    misses: score.misses,
-    mods: (score.mods || {}) as Record<string, unknown>,
-    passed: score.passed,
-    songId: score.songId,
-    speed: score.speed,
-    spin: score.spin,
-    userId: score.userId,
-    username: score.username,
-    avatar_url: score.avatar_url,
-    accuracy: score.accuracy,
-  };
-}
-
-export async function getVisibleTopScoresForBeatmap(
-  beatmapHash: string,
-  limit: number
-): Promise<GetBeatmapTopScoresResult> {
-  if (!beatmapHash) {
-    return { scores: [] };
-  }
-
-  const { data: rpcScores, error } = await supabase.rpc(
-    "get_top_scores_for_beatmap3",
-    { beatmap_hash: beatmapHash }
-  );
-
-  if (error) {
-    return { error: JSON.stringify(error), scores: [] };
-  }
-
-  const scoreData = rpcScores || [];
-
-  const userIds = Array.from(
-    new Set(
-      scoreData
-        .map((score) => score.userId)
-        .filter((userId): userId is number => typeof userId === "number")
-    )
-  );
-  const activeUserIds = await getActiveProfileIdSet(userIds);
-
-  return {
-    scores: scoreData
-      .filter(
-        (score) =>
-          typeof score.userId === "number" && activeUserIds.has(score.userId)
-      )
-      .slice(0, limit)
-      .map(mapBeatmapTopScore),
-  };
-}
+import { Database } from "../types/database";
+import { supabase } from "./supabase";
+
+type BeatmapTopScoreRow =
+  Database["public"]["Functions"]["get_top_scores_for_beatmap3"]["Returns"][number];
+
+export type BeatmapTopScore = {
+  id: number;
+  awarded_sp: number | null;
+  created_at: string;
+  misses: number | null;
+  mods: Record<string, unknown>;
+  passed: boolean | null;
+  songId: string | null;
+  speed: number | null;
+  spin: boolean;
+  userId: number | null;
+  username: string | null;
+  avatar_url: string | null;
+  accuracy: number | null;
+};
+
+type GetBeatmapTopScoresResult = {
+  error?: string;
+  scores: BeatmapTopScore[];
+};
+
+function mapBeatmapTopScore(score: BeatmapTopScoreRow): BeatmapTopScore {
+  return {
+    id: score.id,
+    awarded_sp: score.awarded_sp,
+    created_at: score.created_at,
+    misses: score.misses,
+    mods: (score.mods || {}) as Record<string, unknown>,
+    passed: score.passed,
+    songId: score.songId,
+    speed: score.speed,
+    spin: score.spin,
+    userId: score.userId,
+    username: score.username,
+    avatar_url: score.avatar_url,
+    accuracy: score.accuracy,
+  };
+}
+
+export async function getVisibleTopScoresForBeatmap(
+  beatmapHash: string,
+  limit: number
+): Promise<GetBeatmapTopScoresResult> {
+  if (!beatmapHash) {
+    return { scores: [] };
+  }
+
+  const { data: rpcScores, error } = await supabase.rpc(
+    "get_top_scores_for_beatmap3",
+    { beatmap_hash: beatmapHash, score_limit: limit }
+  );
+
+  if (error) {
+    return { error: JSON.stringify(error), scores: [] };
+  }
+
+  const scoreData = rpcScores || [];
+
+  return {
+    scores: scoreData.slice(0, limit).map(mapBeatmapTopScore),
+  };
+}

package/utils/getUserBySession.ts

@@ -3,12 +3,14 @@ import { decryptString } from "./security";
 import { supabase } from "./supabase";
 
 export async function getUserBySession(session: string): Promise<User | null> {
-  const user = (await supabase.auth.getUser(session)).data.user;
+  const getUserRes = (await supabase.auth.getUser(session))
+  const user = getUserRes.data.user;
   console.log("session:", session);
   if (user) {
     return user;
   }
 
+  console.log("USERERR:", getUserRes.error?.code, getUserRes.error?.message)
   try {
     console.log("trying legacy token");
     const decryptedToken = JSON.parse(decryptString(session)) as {

package/utils/profileUpdateValidation.ts

@@ -0,0 +1,51 @@
+import validator from "validator";
+import removeZeroWidth from "zero-width";
+import { COUNTRY_LIST } from "./countryList";
+
+const countryCodes = new Set(COUNTRY_LIST);
+
+export type ProfileUpdateData = {
+  avatar_url?: string;
+  flag?: string;
+  profile_image?: string;
+  username?: string;
+};
+
+export function normalizeProfileUpdateData(data: ProfileUpdateData) {
+  if (data.username !== undefined) {
+    data.username = removeZeroWidth(data.username);
+
+    if (validator.trim(data.username) !== data.username) {
+      return "Username can't start or end with spaces.";
+    }
+
+    if (data.username.length < 2) {
+      return "Username must be at least 2 characters long";
+    }
+
+    if (data.username.length > 16) {
+      return "Username must be 16 characters or fewer.";
+    }
+
+    if (!/^[A-Za-z0-9._]+$/.test(data.username)) {
+      return "Username can only contain English letters (a-z), numbers (0-9), and up to one '_' or '.'";
+    }
+
+    const specialCharacters = data.username.match(/[._]/g) ?? [];
+    if (specialCharacters.length > 1) {
+      return "Username can contain at most one '_' or one '.'";
+    }
+  }
+
+  if (data.flag !== undefined) {
+    const normalizedFlag = validator.trim(data.flag).toUpperCase();
+
+    if (!countryCodes.has(normalizedFlag as (typeof COUNTRY_LIST)[number])) {
+      return "Flag must be a valid country code.";
+    }
+
+    data.flag = normalizedFlag;
+  }
+
+  return null;
+}

package/utils/redis.ts

@@ -0,0 +1,24 @@
+import { createClient, RedisClientType } from "redis";
+
+let redisClient: RedisClientType;
+
+export const getRedis = async (): Promise<RedisClientType> => {
+    if (!redisClient) {
+        redisClient = createClient({
+            username: process.env.REDIS_USERNAME,
+            password: process.env.REDIS_PASSWORD,
+            socket: {
+                host: process.env.REDIS_HOST,
+                port: Number(process.env.REDIS_PORT),
+            },
+        });
+
+        redisClient.on("error", (err) => {
+            console.error("Redis Client Error", err);
+        });
+
+        await redisClient.connect();
+    }
+
+    return redisClient;
+};