rhythia-api 106.0.0 → 108.0.0

package/api/createBeatmap.ts

@@ -0,0 +1,47 @@
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+import {
+  SSPMParsedMap,
+  SSPMParser,
+} from "rhythia-star-calculator/src/sspmParser";
+
+export const Schema = {
+  input: z.strictObject({
+    url: z.string(),
+  }),
+  output: z.strictObject({
+    hash: z.string().optional(),
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler({
+  url,
+}: (typeof Schema)["input"]["_type"]): Promise<
+  NextResponse<(typeof Schema)["output"]["_type"]>
+> {
+  if (
+    !url.startsWith(`https://rhthia-avatars.s3.eu-central-003.backblazeb2.com/`)
+  )
+    return NextResponse.json({ error: "Invalid url" });
+
+  const request = await fetch(url);
+  const bytes = await request.arrayBuffer();
+  const parser = new SSPMParser(Buffer.from(bytes));
+
+  const parsedData = parser.parse();
+
+  console.log(parsedData);
+  return NextResponse.json({});
+}

package/api/createBeatmapPage.ts

@@ -0,0 +1,47 @@
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+  }),
+  output: z.strictObject({
+    error: z.string().optional(),
+    id: z.number().optional(),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler({
+  session,
+}: (typeof Schema)["input"]["_type"]): Promise<
+  NextResponse<(typeof Schema)["output"]["_type"]>
+> {
+  const user = (await supabase.auth.getUser(session)).data.user!;
+  let { data: userData, error: userError } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id)
+    .single();
+
+  if (!userData) return NextResponse.json({ error: "No user." });
+
+  const upserted = await supabase
+    .from("beatmapPages")
+    .upsert({
+      owner: userData.id,
+    })
+    .select("*")
+    .single();
+  return NextResponse.json({ id: upserted.data?.id });
+}

package/api/getLeaderboard.ts

@@ -74,11 +74,13 @@ export async function getLeaderboard(page = 1, session: string) {
   console.log(startPage, endPage);
   const countQuery = await supabase
     .from("profiles")
-    .select("*", { count: "exact", head: true });
+    .select("*", { count: "exact", head: true })
+    .neq("ban", "excluded");
 
   let { data: queryData, error } = await supabase
     .from("profiles")
     .select("*")
+    .neq("ban", "excluded")
     .order("skill_points", { ascending: false })
     .range(startPage, endPage);
 

package/api/getMapUploadUrl.ts

@@ -22,7 +22,6 @@ const s3Client = new S3Client({
 export const Schema = {
   input: z.strictObject({
     session: z.string(),
-    beatmapHash: z.string(),
     contentLength: z.number(),
     contentType: z.string(),
   }),
@@ -44,7 +43,6 @@ export async function POST(request: Request): Promise<NextResponse> {
 
 export async function handler({
   session,
-  beatmapHash,
   contentLength,
   contentType,
 }: (typeof Schema)["input"]["_type"]): Promise<
@@ -58,7 +56,7 @@ export async function handler({
     });
   }
 
-  const key = `beatmap-${beatmapHash}-${user.id}`;
+  const key = `beatmap-${Date.now()}-${user.id}`;
   const command = new PutObjectCommand({
     Bucket: "rhthia-avatars",
     Key: key,

package/api/getProfile.ts

@@ -113,6 +113,7 @@ export async function handler(
   const { count: playersWithMorePoints, error: rankError } = await supabase
     .from("profiles")
     .select("*", { count: "exact", head: true })
+    .neq("ban", "excluded")
     .gt("skill_points", user.skill_points);
 
   return NextResponse.json({

package/api/searchUsers.ts

@@ -33,6 +33,7 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
   const { data: searchData, error } = await supabase
     .from("profiles")
     .select("id,username")
+    .neq("ban", "excluded")
     .ilike("username", `%${data.text}%`)
     .limit(10);
   return NextResponse.json({

package/api/updateBeatmapPage.ts

@@ -0,0 +1,64 @@
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    id: z.number(),
+    beatmapHash: z.string(),
+  }),
+  output: z.strictObject({
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler({
+  session,
+  beatmapHash,
+  id,
+}: (typeof Schema)["input"]["_type"]): Promise<
+  NextResponse<(typeof Schema)["output"]["_type"]>
+> {
+  const user = (await supabase.auth.getUser(session)).data.user!;
+  let { data: userData, error: userError } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id)
+    .single();
+
+  let { data: pageData, error: pageError } = await supabase
+    .from("beatmapPages")
+    .select("*")
+    .eq("id", id)
+    .single();
+
+  if (!userData) return NextResponse.json({ error: "No user." });
+  if (userData.id !== pageData?.owner)
+    return NextResponse.json({ error: "Non-authz user." });
+
+  const upserted = await supabase
+    .from("beatmapPages")
+    .upsert({
+      id,
+      latestBeatmapHash: beatmapHash,
+      owner: userData.id,
+    })
+    .select("*")
+    .single();
+
+  if (upserted.error) {
+    return NextResponse.json({ error: upserted.error.message });
+  }
+  return NextResponse.json({});
+}

package/index.ts

@@ -1,5 +1,15 @@
 import { handleApi } from "./handleApi"
 
+// ./api/createBeatmap.ts API
+import { Schema as CreateBeatmap } from "./api/createBeatmap"
+export { Schema as SchemaCreateBeatmap } from "./api/createBeatmap"
+export const createBeatmap = handleApi({url:"/api/createBeatmap",...CreateBeatmap})
+
+// ./api/createBeatmapPage.ts API
+import { Schema as CreateBeatmapPage } from "./api/createBeatmapPage"
+export { Schema as SchemaCreateBeatmapPage } from "./api/createBeatmapPage"
+export const createBeatmapPage = handleApi({url:"/api/createBeatmapPage",...CreateBeatmapPage})
+
 // ./api/editAboutMe.ts API
 import { Schema as EditAboutMe } from "./api/editAboutMe"
 export { Schema as SchemaEditAboutMe } from "./api/editAboutMe"
@@ -54,4 +64,9 @@ export const searchUsers = handleApi({url:"/api/searchUsers",...SearchUsers})
 import { Schema as SubmitScore } from "./api/submitScore"
 export { Schema as SchemaSubmitScore } from "./api/submitScore"
 export const submitScore = handleApi({url:"/api/submitScore",...SubmitScore})
+
+// ./api/updateBeatmapPage.ts API
+import { Schema as UpdateBeatmapPage } from "./api/updateBeatmapPage"
+export { Schema as SchemaUpdateBeatmapPage } from "./api/updateBeatmapPage"
+export const updateBeatmapPage = handleApi({url:"/api/updateBeatmapPage",...UpdateBeatmapPage})
 export { handleApi } from "./handleApi"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "106.0.0",
+  "version": "108.0.0",
   "main": "index.ts",
   "scripts": {
     "update": "bun ./scripts/update.ts",
@@ -30,6 +30,7 @@
     "isomorphic-git": "^1.27.1",
     "lodash": "^4.17.21",
     "next": "^14.2.5",
+    "rhythia-star-calculator": "^1.0.4",
     "simple-git": "^3.25.0",
     "supabase": "^1.192.5",
     "tsx": "^4.17.0",

package/scripts/test.ts

@@ -0,0 +1,31 @@
+import { createClient } from "@supabase/supabase-js";
+import { Database } from "../types/database";
+
+export const supabase = createClient<Database>(
+  `https://pfkajngbllcbdzoylrvp.supabase.co`,
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InBma2FqbmdibGxjYmR6b3lscnZwIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTcxODU3NjA3MCwiZXhwIjoyMDM0MTUyMDcwfQ.XKUlQWvzmcYyirM-Zi4nwhiEKcpx1xLS97QUyuR3MoY",
+  {
+    auth: {
+      autoRefreshToken: false,
+      persistSession: false,
+    },
+  }
+);
+
+async function main() {
+  const countQuery = await supabase
+    .from("profiles")
+    .select("*", { count: "exact", head: true })
+    .neq("ban", "excluded");
+
+  let { data: queryData, error } = await supabase
+    .from("profiles")
+    .select("*")
+    .neq("ban", "excluded")
+    .order("skill_points", { ascending: false })
+    .range(0, 50);
+
+  console.log(queryData);
+}
+
+main();

package/types/database.ts

@@ -9,6 +9,42 @@ export type Json =
 export type Database = {
   public: {
     Tables: {
+      beatmapPages: {
+        Row: {
+          created_at: string
+          id: number
+          latestBeatmapHash: string | null
+          owner: number | null
+        }
+        Insert: {
+          created_at?: string
+          id?: number
+          latestBeatmapHash?: string | null
+          owner?: number | null
+        }
+        Update: {
+          created_at?: string
+          id?: number
+          latestBeatmapHash?: string | null
+          owner?: number | null
+        }
+        Relationships: [
+          {
+            foreignKeyName: "beatmapPages_latestBeatmapHash_fkey"
+            columns: ["latestBeatmapHash"]
+            isOneToOne: false
+            referencedRelation: "beatmaps"
+            referencedColumns: ["beatmapHash"]
+          },
+          {
+            foreignKeyName: "beatmapPages_owner_fkey"
+            columns: ["owner"]
+            isOneToOne: false
+            referencedRelation: "profiles"
+            referencedColumns: ["id"]
+          },
+        ]
+      }
       beatmaps: {
         Row: {
           beatmapFile: string | null