rhythia-api 182.0.0 → 185.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "182.0.0",
+  "version": "185.0.0",
   "main": "index.ts",
   "author": "online-contributors",
   "scripts": {
@@ -41,7 +41,7 @@
     "osu-standard-stable": "^5.0.0",
     "sharp": "^0.33.5",
     "simple-git": "^3.25.0",
-    "supabase": "^2.1.1",
+    "supabase": "^2.9.6",
     "tsx": "^4.17.0",
     "utf-8-validate": "^6.0.4",
     "validator": "^13.12.0",

package/types/database.ts

@@ -256,18 +256,21 @@ export type Database = {
           collection: number
           created_at: string
           id: number
+          sort: number
         }
         Insert: {
           beatmapPage?: number | null
           collection: number
           created_at?: string
           id?: number
+          sort?: number
         }
         Update: {
           beatmapPage?: number | null
           collection?: number
           created_at?: string
           id?: number
+          sort?: number
         }
         Relationships: [
           {
@@ -541,10 +544,120 @@ export type Database = {
           total_pages: number
         }[]
       }
-      get_collections_v2: {
+      get_collections_v2:
+        | {
+            Args: {
+              page_number?: number
+              items_per_page?: number
+            }
+            Returns: {
+              id: number
+              title: string
+              description: string
+              created_at: string
+              owner: number
+              owner_username: string
+              owner_avatar_url: string
+              beatmap_count: number
+              star1: number
+              star2: number
+              star3: number
+              star4: number
+              star5: number
+              star6: number
+              star7: number
+              star8: number
+              star9: number
+              star10: number
+              star11: number
+              star12: number
+              star13: number
+              star14: number
+              star15: number
+              star16: number
+              star17: number
+              star18: number
+              total_pages: number
+            }[]
+          }
+        | {
+            Args: {
+              page_number?: number
+              items_per_page?: number
+              owner_filter?: number
+            }
+            Returns: {
+              id: number
+              title: string
+              description: string
+              created_at: string
+              owner: number
+              owner_username: string
+              owner_avatar_url: string
+              beatmap_count: number
+              star1: number
+              star2: number
+              star3: number
+              star4: number
+              star5: number
+              star6: number
+              star7: number
+              star8: number
+              star9: number
+              star10: number
+              star11: number
+              star12: number
+              star13: number
+              star14: number
+              star15: number
+              star16: number
+              star17: number
+              star18: number
+              total_pages: number
+            }[]
+          }
+      get_collections_v3: {
         Args: {
           page_number?: number
           items_per_page?: number
+          owner_filter?: number
+        }
+        Returns: {
+          id: number
+          title: string
+          description: string
+          created_at: string
+          owner: number
+          owner_username: string
+          owner_avatar_url: string
+          beatmap_count: number
+          star1: number
+          star2: number
+          star3: number
+          star4: number
+          star5: number
+          star6: number
+          star7: number
+          star8: number
+          star9: number
+          star10: number
+          star11: number
+          star12: number
+          star13: number
+          star14: number
+          star15: number
+          star16: number
+          star17: number
+          star18: number
+          total_pages: number
+        }[]
+      }
+      get_collections_v4: {
+        Args: {
+          page_number?: number
+          items_per_page?: number
+          owner_filter?: number
+          search_query?: string
         }
         Returns: {
           id: number

package/utils/getUserBySession.ts

@@ -1,48 +1,48 @@
-import { User } from "@supabase/supabase-js";
-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;
-
-  if (user) {
-    return user;
-  }
-
-  try {
-    console.log("trying legacy token");
-    const decryptedToken = JSON.parse(decryptString(session)) as {
-      userId: number;
-      email: string;
-      passKey: string;
-      computerName: string;
-    };
-
-    for (const key of Object.keys(decryptedToken)) {
-      if (decryptedToken[key] === undefined || decryptedToken[key] === null) {
-        return null;
-      }
-    }
-
-    console.log(decryptedToken);
-
-    let { data: queryPasskey, error } = await supabase
-      .from("passkeys")
-      .select("*,profiles(uid)")
-      .eq("id", decryptedToken.userId)
-      .eq("email", decryptedToken.email)
-      .eq("passkey", decryptedToken.passKey)
-      .single();
-
-    console.log(queryPasskey);
-
-    if (!queryPasskey) {
-      return null;
-    }
-
-    return (await supabase.auth.admin.getUserById(queryPasskey.profiles?.uid!))
-      .data.user;
-  } catch (error) {}
-
-  return null;
-}
+import { User } from "@supabase/supabase-js";
+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;
+
+  if (user) {
+    return user;
+  }
+
+  try {
+    console.log("trying legacy token");
+    const decryptedToken = JSON.parse(decryptString(session)) as {
+      userId: number;
+      email: string;
+      passKey: string;
+      computerName: string;
+    };
+
+    for (const key of Object.keys(decryptedToken)) {
+      if (decryptedToken[key] === undefined || decryptedToken[key] === null) {
+        return null;
+      }
+    }
+
+    console.log(decryptedToken);
+
+    let { data: queryPasskey, error } = await supabase
+      .from("passkeys")
+      .select("*,profiles(uid)")
+      .eq("id", decryptedToken.userId)
+      .eq("email", decryptedToken.email)
+      .eq("passkey", decryptedToken.passKey)
+      .single();
+
+    console.log(queryPasskey);
+
+    if (!queryPasskey) {
+      return null;
+    }
+
+    return (await supabase.auth.admin.getUserById(queryPasskey.profiles?.uid!))
+      .data.user;
+  } catch (error) {}
+
+  return null;
+}

package/utils/requestUtils.ts

@@ -1,87 +1,87 @@
-import { NextResponse } from "next/server";
-import { set, ZodObject } from "zod";
-import { getUserBySession } from "./getUserBySession";
-import { supabase } from "./supabase";
-
-interface Props<
-  K = (...args: any[]) => Promise<NextResponse<any>>,
-  T = ZodObject<any>
-> {
-  request: Request;
-  schema: { input: T; output: T };
-  authorization?: Function;
-  activity: K;
-}
-
-export async function protectedApi({
-  request,
-  schema,
-  authorization,
-  activity,
-}: Props) {
-  try {
-    const toParse = await request.json();
-    const data = schema.input.parse(toParse);
-
-    const dataClone = structuredClone(data);
-    if (dataClone) {
-      if (dataClone["token"]) {
-        dataClone["token"] = "********";
-      }
-      Object.keys(dataClone).forEach((key) => {
-        console.log("KEY: ", key, dataClone[key]);
-        if (key == "data") {
-          try {
-            Object.keys(dataClone[key]).forEach((key2) => {
-              console.log("KEY2: ", key2, dataClone[key][key2]);
-            });
-          } catch (error) {}
-        }
-      });
-    }
-
-    setActivity(data);
-    if (authorization) {
-      const authorizationResponse = await authorization(data);
-      if (authorizationResponse) {
-        return authorizationResponse;
-      }
-    }
-    return await activity(data, request);
-  } catch (error) {
-    return NextResponse.json({ error: error.toString() }, { status: 400 });
-  }
-}
-
-export async function setActivity(data: Record<string, any>) {
-  if (data.session) {
-    const user = (await supabase.auth.getUser(data.session)).data.user;
-    if (user) {
-      await supabase.from("profileActivities").upsert({
-        uid: user.id,
-        last_activity: Date.now(),
-      });
-    }
-  }
-}
-
-export async function validUser(data) {
-  if (!data.session) {
-    return NextResponse.json(
-      {
-        error: "Session is missing",
-      },
-      { status: 501 }
-    );
-  }
-
-  const user = await getUserBySession(data.session);
-  if (!user) {
-    return NextResponse.json(
-      {
-        error: "Invalid user session",
-      },
-      { status: 400 }
-    );
-  }
-}
+import { NextResponse } from "next/server";
+import { set, ZodObject } from "zod";
+import { getUserBySession } from "./getUserBySession";
+import { supabase } from "./supabase";
+
+interface Props<
+  K = (...args: any[]) => Promise<NextResponse<any>>,
+  T = ZodObject<any>
+> {
+  request: Request;
+  schema: { input: T; output: T };
+  authorization?: Function;
+  activity: K;
+}
+
+export async function protectedApi({
+  request,
+  schema,
+  authorization,
+  activity,
+}: Props) {
+  try {
+    const toParse = await request.json();
+    const data = schema.input.parse(toParse);
+
+    const dataClone = structuredClone(data);
+    if (dataClone) {
+      if (dataClone["token"]) {
+        dataClone["token"] = "********";
+      }
+      Object.keys(dataClone).forEach((key) => {
+        console.log("KEY: ", key, dataClone[key]);
+        if (key == "data") {
+          try {
+            Object.keys(dataClone[key]).forEach((key2) => {
+              console.log("KEY2: ", key2, dataClone[key][key2]);
+            });
+          } catch (error) {}
+        }
+      });
+    }
+
+    setActivity(data);
+    if (authorization) {
+      const authorizationResponse = await authorization(data);
+      if (authorizationResponse) {
+        return authorizationResponse;
+      }
+    }
+    return await activity(data, request);
+  } catch (error) {
+    return NextResponse.json({ error: error.toString() }, { status: 400 });
+  }
+}
+
+export async function setActivity(data: Record<string, any>) {
+  if (data.session) {
+    const user = (await supabase.auth.getUser(data.session)).data.user;
+    if (user) {
+      await supabase.from("profileActivities").upsert({
+        uid: user.id,
+        last_activity: Date.now(),
+      });
+    }
+  }
+}
+
+export async function validUser(data) {
+  if (!data.session) {
+    return NextResponse.json(
+      {
+        error: "Session is missing",
+      },
+      { status: 501 }
+    );
+  }
+
+  const user = await getUserBySession(data.session);
+  if (!user) {
+    return NextResponse.json(
+      {
+        error: "Invalid user session",
+      },
+      { status: 400 }
+    );
+  }
+}

package/utils/security.ts

@@ -1,20 +1,20 @@
-import { xchacha20poly1305 } from "@noble/ciphers/chacha";
-import { managedNonce } from "@noble/ciphers/webcrypto";
-import {
-  bytesToHex,
-  bytesToUtf8,
-  hexToBytes,
-  utf8ToBytes,
-} from "@noble/ciphers/utils";
-const key = hexToBytes(process.env.TOKEN_SECRET || "");
-const chacha = managedNonce(xchacha20poly1305)(key); // manages nonces for you
-
-export function encryptString(str: string) {
-  const data = utf8ToBytes(str);
-  return bytesToHex(chacha.encrypt(data));
-}
-
-export function decryptString(str: string) {
-  const data = hexToBytes(str);
-  return bytesToUtf8(chacha.decrypt(data));
-}
+import { xchacha20poly1305 } from "@noble/ciphers/chacha";
+import { managedNonce } from "@noble/ciphers/webcrypto";
+import {
+  bytesToHex,
+  bytesToUtf8,
+  hexToBytes,
+  utf8ToBytes,
+} from "@noble/ciphers/utils";
+const key = hexToBytes(process.env.TOKEN_SECRET || "");
+const chacha = managedNonce(xchacha20poly1305)(key); // manages nonces for you
+
+export function encryptString(str: string) {
+  const data = utf8ToBytes(str);
+  return bytesToHex(chacha.encrypt(data));
+}
+
+export function decryptString(str: string) {
+  const data = hexToBytes(str);
+  return bytesToUtf8(chacha.decrypt(data));
+}

package/utils/star-calc/index.ts

@@ -1,72 +1,72 @@
-import { BeatmapDecoder, BeatmapEncoder } from "osu-parsers";
-import { StandardRuleset } from "osu-standard-stable";
-import { sampleMap } from "./osuUtils";
-import { SSPMParsedMap } from "./sspmParser";
-import { SSPMMap, V1SSPMParser } from "./sspmv1Parser";
-
-export function rateMap(map: SSPMParsedMap) {
-  let notes = map.markers
-    .filter((marker) => marker.type === 0)
-    .map((marker) => ({
-      time: marker.position,
-      x: marker.data["field0"].x,
-      y: marker.data["field0"].y,
-    }));
-
-  return rate(notes);
-}
-
-export function rateMapNotes(map: [number, number, number][]) {
-  let notes = map.map((marker) => ({
-    time: marker[2],
-    x: marker[0],
-    y: marker[1],
-  }));
-
-  return rate(notes);
-}
-
-export function rateMapOld(map: SSPMMap) {
-  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 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;
-    }
-
-    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);
-  return difficultyAttributes.starRating;
-}
-
-const distance = (x1, y1, x2, y2) => Math.hypot(x2 - x1, y2 - y1);
+import { BeatmapDecoder, BeatmapEncoder } from "osu-parsers";
+import { StandardRuleset } from "osu-standard-stable";
+import { sampleMap } from "./osuUtils";
+import { SSPMParsedMap } from "./sspmParser";
+import { SSPMMap, V1SSPMParser } from "./sspmv1Parser";
+
+export function rateMap(map: SSPMParsedMap) {
+  let notes = map.markers
+    .filter((marker) => marker.type === 0)
+    .map((marker) => ({
+      time: marker.position,
+      x: marker.data["field0"].x,
+      y: marker.data["field0"].y,
+    }));
+
+  return rate(notes);
+}
+
+export function rateMapNotes(map: [number, number, number][]) {
+  let notes = map.map((marker) => ({
+    time: marker[2],
+    x: marker[0],
+    y: marker[1],
+  }));
+
+  return rate(notes);
+}
+
+export function rateMapOld(map: SSPMMap) {
+  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 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;
+    }
+
+    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);
+  return difficultyAttributes.starRating;
+}
+
+const distance = (x1, y1, x2, y2) => Math.hypot(x2 - x1, y2 - y1);