rhythia-api 105.0.0 → 107.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/editProfile.ts

@@ -47,6 +47,7 @@ export async function handler(
   }
 
   const user = (await supabase.auth.getUser(data.session)).data.user!;
+
   let userData: Database["public"]["Tables"]["profiles"]["Update"];
 
   // Find user's entry
@@ -67,6 +68,20 @@ export async function handler(
     userData = queryUserData[0];
   }
 
+  if (
+    userData.ban == "excluded" ||
+    userData.ban == "restricted" ||
+    userData.ban == "silenced"
+  ) {
+    return NextResponse.json(
+      {
+        error:
+          "Silenced, restricted or excluded players can't update their profile.",
+      },
+      { status: 404 }
+    );
+  }
+
   const upsertPayload: Database["public"]["Tables"]["profiles"]["Update"] = {
     id: userData.id,
     computedUsername: data.data.username?.toLowerCase(),

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

@@ -0,0 +1,74 @@
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+import {
+  PutBucketCorsCommand,
+  PutObjectCommand,
+  S3Client,
+} from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+
+const s3Client = new S3Client({
+  region: "auto",
+  endpoint: "https://s3.eu-central-003.backblazeb2.com",
+  credentials: {
+    secretAccessKey: "K0039mm4iKsteQOXpZSzf0+VDzuH89U",
+    accessKeyId: "003c245e893e8060000000001",
+  },
+});
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    contentLength: z.number(),
+    contentType: z.string(),
+  }),
+  output: z.strictObject({
+    error: z.string().optional(),
+    url: z.string().optional(),
+    objectKey: 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,
+  contentLength,
+  contentType,
+}: (typeof Schema)["input"]["_type"]): Promise<
+  NextResponse<(typeof Schema)["output"]["_type"]>
+> {
+  const user = (await supabase.auth.getUser(session)).data.user!;
+
+  if (contentLength > 50000000) {
+    return NextResponse.json({
+      error: "Max content length exceeded.",
+    });
+  }
+
+  const key = `beatmap-${Date.now()}-${user.id}`;
+  const command = new PutObjectCommand({
+    Bucket: "rhthia-avatars",
+    Key: key,
+    ContentLength: contentLength,
+    ContentType: contentType,
+  });
+
+  const presigned = await getSignedUrl(s3Client, command, {
+    expiresIn: 3600,
+  });
+  return NextResponse.json({
+    url: presigned,
+    objectKey: key,
+  });
+}

package/api/getProfile.ts

@@ -21,6 +21,7 @@ export const Schema = {
         flag: z.string().nullable(),
         id: z.number(),
         uid: z.string().nullable(),
+        ban: z.string().nullable(),
         username: z.string().nullable(),
         verified: z.boolean().nullable(),
         play_count: z.number().nullable(),
@@ -86,7 +87,7 @@ export async function handler(
             about_me: "",
             avatar_url:
               "https://rhthia-avatars.s3.eu-central-003.backblazeb2.com/user-avatar-1725309193296-72002e6b-321c-4f60-a692-568e0e75147d",
-            badges: ["Early Bird"],
+            badges: [],
             username: `${user.user_metadata.full_name.slice(0, 20)}${Math.round(
               Math.random() * 900000 + 100000
             )}`,
@@ -112,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"
@@ -20,6 +30,11 @@ import { Schema as GetLeaderboard } from "./api/getLeaderboard"
 export { Schema as SchemaGetLeaderboard } from "./api/getLeaderboard"
 export const getLeaderboard = handleApi({url:"/api/getLeaderboard",...GetLeaderboard})
 
+// ./api/getMapUploadUrl.ts API
+import { Schema as GetMapUploadUrl } from "./api/getMapUploadUrl"
+export { Schema as SchemaGetMapUploadUrl } from "./api/getMapUploadUrl"
+export const getMapUploadUrl = handleApi({url:"/api/getMapUploadUrl",...GetMapUploadUrl})
+
 // ./api/getProfile.ts API
 import { Schema as GetProfile } from "./api/getProfile"
 export { Schema as SchemaGetProfile } from "./api/getProfile"
@@ -49,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": "105.0.0",
+  "version": "107.0.0",
   "main": "index.ts",
   "scripts": {
     "update": "bun ./scripts/update.ts",
@@ -30,8 +30,9 @@
     "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.191.3",
+    "supabase": "^1.192.5",
     "tsx": "^4.17.0",
     "utf-8-validate": "^6.0.4",
     "zod": "^3.23.8"

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,11 +9,49 @@ 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
           beatmapHash: string
           created_at: string
           difficulty: number | null
+          image: string | null
           length: number | null
           noteCount: number | null
           playcount: number | null
@@ -21,9 +59,11 @@ export type Database = {
           title: string | null
         }
         Insert: {
+          beatmapFile?: string | null
           beatmapHash: string
           created_at?: string
           difficulty?: number | null
+          image?: string | null
           length?: number | null
           noteCount?: number | null
           playcount?: number | null
@@ -31,9 +71,11 @@ export type Database = {
           title?: string | null
         }
         Update: {
+          beatmapFile?: string | null
           beatmapHash?: string
           created_at?: string
           difficulty?: number | null
+          image?: string | null
           length?: number | null
           noteCount?: number | null
           playcount?: number | null
@@ -47,6 +89,8 @@ export type Database = {
           about_me: string | null
           avatar_url: string | null
           badges: Json | null
+          ban: Database["public"]["Enums"]["banTypes"] | null
+          bannedAt: number | null
           computedUsername: string | null
           created_at: number | null
           flag: string | null
@@ -63,6 +107,8 @@ export type Database = {
           about_me?: string | null
           avatar_url?: string | null
           badges?: Json | null
+          ban?: Database["public"]["Enums"]["banTypes"] | null
+          bannedAt?: number | null
           computedUsername?: string | null
           created_at?: number | null
           flag?: string | null
@@ -79,6 +125,8 @@ export type Database = {
           about_me?: string | null
           avatar_url?: string | null
           badges?: Json | null
+          ban?: Database["public"]["Enums"]["banTypes"] | null
+          bannedAt?: number | null
           computedUsername?: string | null
           created_at?: number | null
           flag?: string | null
@@ -160,7 +208,7 @@ export type Database = {
       [_ in never]: never
     }
     Enums: {
-      [_ in never]: never
+      banTypes: "cool" | "silenced" | "restricted" | "excluded"
     }
     CompositeTypes: {
       [_ in never]: never