rhythia-api 173.0.0 → 175.0.0

package/api/addCollectionMap.ts

@@ -0,0 +1,70 @@
+import { NextResponse } from "next/server";
+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";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    collection: z.number(),
+    beatmapPage: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  const user = (await getUserBySession(data.session)) as User;
+  let { data: queryUserData, error: userError } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id)
+    .single();
+
+  if (!queryUserData) {
+    return NextResponse.json({ error: "Can't find user" });
+  }
+
+  let { data: queryCollectionData, error: collectionError } = await supabase
+    .from("beatmapCollections")
+    .select("*")
+    .eq("id", data.collection)
+    .single();
+
+  let { data: queryBeatmapData, error: beatmapData } = await supabase
+    .from("beatmapPages")
+    .select("*")
+    .eq("id", data.beatmapPage)
+    .single();
+
+  if (!queryCollectionData) {
+    return NextResponse.json({ error: "Can't find collection" });
+  }
+
+  if (!queryBeatmapData) {
+    return NextResponse.json({ error: "Can't find beatmap page" });
+  }
+
+  if (queryCollectionData.owner !== queryUserData.id) {
+    return NextResponse.json({ error: "You can't update foreign collections" });
+  }
+
+  await supabase.from("collectionRelations").insert({
+    collection: data.collection,
+    beatmapPage: data.beatmapPage,
+  });
+
+  return NextResponse.json({});
+}

package/api/chartPublicStats.ts

@@ -0,0 +1,32 @@
+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({}),
+  output: z.object({}),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  // 30 minutes activity
+  const countOnline = await supabase
+    .from("profileActivities")
+    .select("*", { count: "exact", head: true })
+    .gt("last_activity", Date.now() - 1800000);
+
+  await supabase.from("chartedValues").insert({
+    type: "online_players",
+    value: countOnline.count,
+  });
+  return NextResponse.json({});
+}

package/api/createBeatmap.ts

@@ -86,6 +86,9 @@ export async function handler({
     .single();
 
   if (beatmapPage) {
+    if (beatmapPage?.status !== "UNRANKED")
+      return NextResponse.json({ error: "Only unranked maps can be updated" });
+
     if (!updateFlag) {
       return NextResponse.json({ error: "Already Exists" });
     } else if (beatmapPage.owner !== userData.id) {

package/api/createCollection.ts

@@ -0,0 +1,46 @@
+import { NextResponse } from "next/server";
+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";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    title: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  const user = (await getUserBySession(data.session)) as User;
+  let { data: queryUserData, error: userError } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id)
+    .single();
+
+  if (!queryUserData) {
+    return NextResponse.json({ error: "Can't find user" });
+  }
+
+  await supabase.from("beatmapCollections").insert({
+    title: data.title,
+    description: "",
+    owner: queryUserData.id,
+  });
+
+  return NextResponse.json({});
+}

package/api/getCollection.ts

@@ -0,0 +1,112 @@
+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(),
+    collection: z.number(),
+  }),
+  output: z.object({
+    collection: z.object({
+      title: z.string(),
+      description: z.string(),
+      beatmaps: z.array(
+        z.object({
+          id: z.number(),
+          playcount: z.number().nullable().optional(),
+          created_at: z.string().nullable().optional(),
+          difficulty: 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(),
+          status: z.string().nullable().optional(),
+          tags: z.string().nullable().optional(),
+        })
+      ),
+    }),
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  let { data: queryCollectionData, error: collectionError } = await supabase
+    .from("beatmapCollections")
+    .select("*")
+    .eq("id", data.collection)
+    .single();
+
+  if (!queryCollectionData) {
+    return NextResponse.json({ error: "Can't find collection" });
+  }
+
+  let { data: queryBeatmaps, error: beatmapsError } = await supabase
+    .from("collectionRelations")
+    .select(
+      `
+        *,
+        beatmapPages!inner(
+          owner,
+          created_at,
+          id,
+          status,
+          tags,
+          beatmaps!inner(
+            playcount,
+            ranked,
+            beatmapFile,
+            image,
+            starRating,
+            difficulty,
+            length,
+            title
+          ),
+          profiles!inner(
+            username
+          )
+        )
+      `
+    )
+    .eq("collection", data.collection);
+
+  const formattedBeatmaps =
+    queryBeatmaps?.map((relation) => ({
+      id: relation.beatmapPages.id,
+      playcount: relation.beatmapPages.beatmaps.playcount,
+      created_at: relation.beatmapPages.created_at,
+      difficulty: relation.beatmapPages.beatmaps.difficulty,
+      length: relation.beatmapPages.beatmaps.length,
+      title: relation.beatmapPages.beatmaps.title,
+      ranked: relation.beatmapPages.beatmaps.ranked,
+      beatmapFile: relation.beatmapPages.beatmaps.beatmapFile,
+      image: relation.beatmapPages.beatmaps.image,
+      starRating: relation.beatmapPages.beatmaps.starRating,
+      owner: relation.beatmapPages.owner,
+      ownerUsername: relation.beatmapPages.profiles.username,
+      status: relation.beatmapPages.status,
+      tags: relation.beatmapPages.tags,
+    })) || [];
+
+  return NextResponse.json({
+    collection: {
+      title: queryCollectionData.title,
+      description: queryCollectionData.description,
+      beatmaps: formattedBeatmaps,
+    },
+  });
+}

package/api/getCollections.ts

@@ -0,0 +1,72 @@
+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(),
+  }),
+  output: z.object({
+    collections: z.array(
+      z.object({
+        id: z.number(),
+        title: z.string(),
+        description: z.string(),
+        beatmapCount: z.number(),
+        createdAt: z.string().nullable().optional(),
+        updatedAt: z.string().nullable().optional(),
+      })
+    ),
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  // First get all collections
+  let { data: collections, error: collectionsError } = await supabase
+    .from("beatmapCollections")
+    .select(
+      `
+      *,
+      collectionRelations!left(count)
+    `
+    )
+    .returns<
+      Array<{
+        id: number;
+        title: string;
+        description: string;
+        created_at: string | null;
+        updated_at: string | null;
+        collectionRelations: Array<{ count: number }>;
+      }>
+    >();
+
+  if (collectionsError) {
+    return NextResponse.json({ error: "Error fetching collections" });
+  }
+
+  const formattedCollections =
+    collections?.map((collection) => ({
+      id: collection.id,
+      title: collection.title,
+      description: collection.description,
+      beatmapCount: collection.collectionRelations?.[0]?.count ?? 0,
+      createdAt: collection.created_at,
+      updatedAt: collection.updated_at,
+    })) || [];
+
+  return NextResponse.json({
+    collections: formattedCollections,
+  });
+}

package/api/getPublicStats.ts

@@ -10,6 +10,12 @@ export const Schema = {
     beatmaps: z.number(),
     scores: z.number(),
     onlineUsers: z.number(),
+    countChart: z.array(
+      z.object({
+        type: z.string(),
+        value: z.number(),
+      })
+    ),
     lastBeatmaps: z.array(
       z.object({
         id: z.number().nullable().optional(),
@@ -127,11 +133,18 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
     .select("*", { count: "exact", head: true })
     .gt("last_activity", Date.now() - 1800000);
 
+  const countChart = await supabase
+    .from("chartedValues")
+    .select("*")
+    .eq("type", "online_players")
+    .gt("created_at", new Date(Date.now() - 86400000).toISOString());
+
   return NextResponse.json({
     beatmaps: countBeatmapsQuery.count,
     profiles: countProfilesQuery.count,
     scores: countScoresQuery.count,
     onlineUsers: countOnline.count,
+    countChart: countChart.data,
     lastBeatmaps: beatmapPage?.map((e) => ({
       playcount: e.beatmaps?.playcount,
       created_at: e.created_at,

package/api/getRawStarRating.ts

@@ -2,6 +2,7 @@ import { NextResponse } from "next/server";
 import z from "zod";
 import { protectedApi } from "../utils/requestUtils";
 import { rateMapNotes } from "../utils/star-calc";
+import { calculatePerformancePoints } from "./submitScore";
 
 export const Schema = {
   input: z.strictObject({
@@ -41,6 +42,16 @@ export async function handler(
   return NextResponse.json({
     beatmap: {
       starRating,
+      rp: {
+        "S---": calculatePerformancePoints((starRating * 1) / 1.35, 1),
+        "S--": calculatePerformancePoints((starRating * 1) / 1.25, 1),
+        "S-": calculatePerformancePoints((starRating * 1) / 1.15, 1),
+        S: calculatePerformancePoints(starRating * 1, 1),
+        "S+": calculatePerformancePoints(starRating * 1.15, 1),
+        "S++": calculatePerformancePoints(starRating * 1.25, 1),
+        "S+++": calculatePerformancePoints(starRating * 1.35, 1),
+        "S++++": calculatePerformancePoints(starRating * 1.45, 1),
+      },
     },
   });
 }

package/index.ts

@@ -1,5 +1,22 @@
 import { handleApi } from "./handleApi"
 
+// ./api/addCollectionMap.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    collection: z.number(),
+    beatmapPage: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};*/
+import { Schema as AddCollectionMap } from "./api/addCollectionMap"
+export { Schema as SchemaAddCollectionMap } from "./api/addCollectionMap"
+export const addCollectionMap = handleApi({url:"/api/addCollectionMap",...AddCollectionMap})
+
 // ./api/approveMap.ts API
 
 /*
@@ -16,6 +33,17 @@ import { Schema as ApproveMap } from "./api/approveMap"
 export { Schema as SchemaApproveMap } from "./api/approveMap"
 export const approveMap = handleApi({url:"/api/approveMap",...ApproveMap})
 
+// ./api/chartPublicStats.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({}),
+  output: z.object({}),
+};*/
+import { Schema as ChartPublicStats } from "./api/chartPublicStats"
+export { Schema as SchemaChartPublicStats } from "./api/chartPublicStats"
+export const chartPublicStats = handleApi({url:"/api/chartPublicStats",...ChartPublicStats})
+
 // ./api/createBeatmap.ts API
 
 /*
@@ -67,6 +95,22 @@ import { Schema as CreateClan } from "./api/createClan"
 export { Schema as SchemaCreateClan } from "./api/createClan"
 export const createClan = handleApi({url:"/api/createClan",...CreateClan})
 
+// ./api/createCollection.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    title: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};*/
+import { Schema as CreateCollection } from "./api/createCollection"
+export { Schema as SchemaCreateCollection } from "./api/createCollection"
+export const createCollection = handleApi({url:"/api/createCollection",...CreateCollection})
+
 // ./api/deleteBeatmapPage.ts API
 
 /*
@@ -403,6 +447,69 @@ import { Schema as GetClan } from "./api/getClan"
 export { Schema as SchemaGetClan } from "./api/getClan"
 export const getClan = handleApi({url:"/api/getClan",...GetClan})
 
+// ./api/getCollection.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    collection: z.number(),
+  }),
+  output: z.object({
+    collection: z.object({
+      title: z.string(),
+      description: z.string(),
+      beatmaps: z.array(
+        z.object({
+          id: z.number(),
+          playcount: z.number().nullable().optional(),
+          created_at: z.string().nullable().optional(),
+          difficulty: 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(),
+          status: z.string().nullable().optional(),
+          tags: z.string().nullable().optional(),
+        })
+      ),
+    }),
+    error: z.string().optional(),
+  }),
+};*/
+import { Schema as GetCollection } from "./api/getCollection"
+export { Schema as SchemaGetCollection } from "./api/getCollection"
+export const getCollection = handleApi({url:"/api/getCollection",...GetCollection})
+
+// ./api/getCollections.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+  }),
+  output: z.object({
+    collections: z.array(
+      z.object({
+        id: z.number(),
+        title: z.string(),
+        description: z.string(),
+        beatmapCount: z.number(),
+        createdAt: z.string().nullable().optional(),
+        updatedAt: z.string().nullable().optional(),
+      })
+    ),
+    error: z.string().optional(),
+  }),
+};*/
+import { Schema as GetCollections } from "./api/getCollections"
+export { Schema as SchemaGetCollections } from "./api/getCollections"
+export const getCollections = handleApi({url:"/api/getCollections",...GetCollections})
+
 // ./api/getLeaderboard.ts API
 
 /*
@@ -540,6 +647,12 @@ export const Schema = {
     beatmaps: z.number(),
     scores: z.number(),
     onlineUsers: z.number(),
+    countChart: z.array(
+      z.object({
+        type: z.string(),
+        value: z.number(),
+      })
+    ),
     lastBeatmaps: z.array(
       z.object({
         id: z.number().nullable().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "173.0.0",
+  "version": "175.0.0",
   "main": "index.ts",
   "author": "online-contributors",
   "scripts": {

package/types/database.ts

@@ -9,6 +9,38 @@ export type Json =
 export type Database = {
   public: {
     Tables: {
+      beatmapCollections: {
+        Row: {
+          created_at: string
+          description: string
+          id: number
+          owner: number
+          title: string
+        }
+        Insert: {
+          created_at?: string
+          description: string
+          id?: number
+          owner: number
+          title: string
+        }
+        Update: {
+          created_at?: string
+          description?: string
+          id?: number
+          owner?: number
+          title?: string
+        }
+        Relationships: [
+          {
+            foreignKeyName: "beatmapCollections_owner_fkey"
+            columns: ["owner"]
+            isOneToOne: false
+            referencedRelation: "profiles"
+            referencedColumns: ["id"]
+          },
+        ]
+      }
       beatmapPageComments: {
         Row: {
           beatmapPage: number
@@ -153,6 +185,27 @@ export type Database = {
         }
         Relationships: []
       }
+      chartedValues: {
+        Row: {
+          created_at: string
+          id: number
+          type: string | null
+          value: number | null
+        }
+        Insert: {
+          created_at?: string
+          id?: number
+          type?: string | null
+          value?: number | null
+        }
+        Update: {
+          created_at?: string
+          id?: number
+          type?: string | null
+          value?: number | null
+        }
+        Relationships: []
+      }
       clans: {
         Row: {
           acronym: string | null
@@ -194,6 +247,42 @@ export type Database = {
           },
         ]
       }
+      collectionRelations: {
+        Row: {
+          beatmapPage: number | null
+          collection: number
+          created_at: string
+          id: number
+        }
+        Insert: {
+          beatmapPage?: number | null
+          collection: number
+          created_at?: string
+          id?: number
+        }
+        Update: {
+          beatmapPage?: number | null
+          collection?: number
+          created_at?: string
+          id?: number
+        }
+        Relationships: [
+          {
+            foreignKeyName: "collectionRelations_beatmapPage_fkey"
+            columns: ["beatmapPage"]
+            isOneToOne: false
+            referencedRelation: "beatmapPages"
+            referencedColumns: ["id"]
+          },
+          {
+            foreignKeyName: "collectionRelations_collection_fkey"
+            columns: ["collection"]
+            isOneToOne: false
+            referencedRelation: "beatmapCollections"
+            referencedColumns: ["id"]
+          },
+        ]
+      }
       discordWebhooks: {
         Row: {
           id: number

package/utils/star-calc/index.ts

@@ -4,19 +4,6 @@ import { sampleMap } from "./osuUtils";
 import { SSPMParsedMap } from "./sspmParser";
 import { SSPMMap, V1SSPMParser } from "./sspmv1Parser";
 
-function easeInExpoDeq(x: number) {
-  return x === 0 ? 0 : Math.pow(2, 35 * x - 35);
-}
-
-export function calculatePerformancePoints(
-  starRating: number,
-  accuracy: number
-) {
-  return Math.round(
-    Math.pow((starRating * easeInExpoDeq(accuracy) * 100) / 2, 2) / 1000
-  );
-}
-
 export function rateMap(map: SSPMParsedMap) {
   let notes = map.markers
     .filter((marker) => marker.type === 0)
@@ -31,9 +18,9 @@ export function rateMap(map: SSPMParsedMap) {
 
 export function rateMapNotes(map: [number, number, number][]) {
   let notes = map.map((marker) => ({
-    time: marker[0],
-    x: marker[1],
-    y: marker[2],
+    time: marker[2],
+    x: marker[0],
+    y: marker[1],
   }));
 
   return rate(notes);