rhythia-api 235.0.0 → 237.0.0

package/api/getBeatmaps.ts

@@ -1,41 +1,41 @@
-import { NextResponse } from "../utils/response";
-import z from "zod";
-import { protectedApi } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    textFilter: z.string().optional(),
-    authorFilter: z.string().optional(),
-    tagsFilter: z.string().optional(),
-    page: z.number().default(1),
-    maxStars: z.number().optional(),
-    minLength: z.number().optional(),
-    maxLength: z.number().optional(),
-    minStars: z.number().optional(),
-    creator: z.number().optional(),
-    status: z.string().optional(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-    total: z.number(),
-    viewPerPage: z.number(),
-    currentPage: z.number(),
-    beatmaps: z
+import { NextResponse } from "../utils/response";
+import z from "zod";
+import { protectedApi } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    textFilter: z.string().optional(),
+    authorFilter: z.string().optional(),
+    tagsFilter: z.string().optional(),
+    page: z.number().default(1),
+    maxStars: z.number().optional(),
+    minLength: z.number().optional(),
+    maxLength: z.number().optional(),
+    minStars: z.number().optional(),
+    creator: z.number().optional(),
+    status: z.string().optional(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    total: z.number(),
+    viewPerPage: z.number(),
+    currentPage: z.number(),
+    beatmaps: z
       .array(
         z.object({
           id: z.number(),
           playcount: z.number().nullable().optional(),
           created_at: z.string().nullable().optional(),
-          difficulty: z.number().nullable().optional(),
-          noteCount: 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(),
+          difficulty: z.number().nullable().optional(),
+          noteCount: 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(),
           ownerAvatar: z.string().nullable().optional(),
@@ -46,30 +46,31 @@ export const Schema = {
         })
       )
       .optional(),
-  }),
-};
-
-export async function POST(request: Request): Promise<NextResponse> {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: () => {},
-    activity: handler,
-  });
-}
-
-export async function handler(
-  data: (typeof Schema)["input"]["_type"]
-): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
-  const result = await getBeatmaps(data);
-  return NextResponse.json(result);
-}
-
-const VIEW_PER_PAGE = 50;
-
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(
+  data: (typeof Schema)["input"]["_type"]
+): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  const result = await getBeatmaps(data);
+  return NextResponse.json(result);
+}
+
+const VIEW_PER_PAGE = 50;
+
 export async function getBeatmaps(data: (typeof Schema)["input"]["_type"]) {
   const startPage = (data.page - 1) * VIEW_PER_PAGE;
   const endPage = startPage + VIEW_PER_PAGE - 1;
+  // status filter is a bit uncanny, we store qualified as a field, but it acts as a status in the UI.
   const statusFilter = data.status?.toUpperCase();
   let countQry = supabase
     .from("beatmapPages")
@@ -100,14 +101,14 @@ export async function getBeatmaps(data: (typeof Schema)["input"]["_type"]) {
         video_url,
         beatmaps!inner(
           playcount,
-          ranked,
-          beatmapFile,
-          image,
-          starRating,
-          difficulty,
-          length,
-          title
-        ),
+          ranked,
+          beatmapFile,
+          image,
+          starRating,
+          difficulty,
+          length,
+          title
+        ),
         profiles!inner(
           username
         )`
@@ -173,18 +174,18 @@ export async function getBeatmaps(data: (typeof Schema)["input"]["_type"]) {
   return {
     total: countQuery.count || 0,
     viewPerPage: VIEW_PER_PAGE,
-    currentPage: data.page,
-    beatmaps: queryData.data?.map((beatmapPage) => ({
-      id: beatmapPage.id,
-      tags: beatmapPage.tags,
-      playcount: beatmapPage.beatmaps?.playcount,
-      created_at: beatmapPage.created_at,
-      difficulty: beatmapPage.beatmaps?.difficulty,
-      title: beatmapPage.beatmaps?.title,
-      ranked: beatmapPage.beatmaps?.ranked,
-      length: beatmapPage.beatmaps?.length,
-      beatmapFile: beatmapPage.beatmaps?.beatmapFile,
-      image: beatmapPage.beatmaps?.image,
+    currentPage: data.page,
+    beatmaps: queryData.data?.map((beatmapPage) => ({
+      id: beatmapPage.id,
+      tags: beatmapPage.tags,
+      playcount: beatmapPage.beatmaps?.playcount,
+      created_at: beatmapPage.created_at,
+      difficulty: beatmapPage.beatmaps?.difficulty,
+      title: beatmapPage.beatmaps?.title,
+      ranked: beatmapPage.beatmaps?.ranked,
+      length: beatmapPage.beatmaps?.length,
+      beatmapFile: beatmapPage.beatmaps?.beatmapFile,
+      image: beatmapPage.beatmaps?.image,
       starRating: beatmapPage.beatmaps?.starRating,
       owner: beatmapPage.owner,
       status: beatmapPage.status,

package/api/getCollection.ts

@@ -9,16 +9,17 @@ export const Schema = {
     collection: z.number(),
   }),
   output: z.object({
-    collection: z.object({
-      title: z.string(),
-      description: z.string(),
-      owner: z.object({
-        id: z.number(),
-        username: z.string(),
-      }),
-      isList: z.boolean(),
-      beatmaps: z.array(
-        z.object({
+    collection: z.object({
+      title: z.string(),
+      description: z.string(),
+      owner: z.object({
+        id: z.number(),
+        username: z.string(),
+        avatar_url: z.string().nullable(),
+      }),
+      isList: z.boolean(),
+      beatmaps: z.array(
+        z.object({
           id: z.number(),
           playcount: z.number().nullable().optional(),
           created_at: z.string().nullable().optional(),
@@ -54,13 +55,14 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
     .from("beatmapCollections")
     .select(
       `
-      *,
-      profiles!inner(
-        id,
-        username
-      )
-      `
-    )
+      *,
+      profiles!inner(
+        id,
+        username,
+        avatar_url
+      )
+      `
+    )
     .eq("id", data.collection)
     .single();
 
@@ -117,12 +119,13 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
 
   return NextResponse.json({
     collection: {
-      owner: {
-        username: queryCollectionData.profiles.username,
-        id: queryCollectionData.profiles.id,
-      },
-      isList: queryCollectionData.is_list,
-      title: queryCollectionData.title,
+      owner: {
+        username: queryCollectionData.profiles.username,
+        id: queryCollectionData.profiles.id,
+        avatar_url: queryCollectionData.profiles.avatar_url,
+      },
+      isList: queryCollectionData.is_list,
+      title: queryCollectionData.title,
       description: queryCollectionData.description,
       beatmaps: formattedBeatmaps,
     },

package/api/reportProfile.ts

@@ -0,0 +1,103 @@
+import { NextResponse } from "../utils/response";
+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";
+import { postProfileReportWebhook } from "../utils/profileReportWebhook";
+
+const MAX_DESCRIPTION_LENGTH = 1000;
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    profileId: z.number(),
+    description: 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,
+  profileId,
+  description,
+}: (typeof Schema)["input"]["_type"]): Promise<
+  NextResponse<(typeof Schema)["output"]["_type"]>
+> {
+  const trimmedDescription = description.trim();
+
+  if (!trimmedDescription.length) {
+    return NextResponse.json({ error: "Report description is required." });
+  }
+
+  if (trimmedDescription.length > MAX_DESCRIPTION_LENGTH) {
+    return NextResponse.json({
+      error: `Report description exceeds ${MAX_DESCRIPTION_LENGTH} characters.`,
+    });
+  }
+
+  const user = (await getUserBySession(session)) as User;
+  const { data: reporterProfile } = await supabase
+    .from("profiles")
+    .select("id,ban,username,computedUsername,avatar_url")
+    .eq("uid", user.id)
+    .single();
+
+  if (!reporterProfile) {
+    return NextResponse.json({ error: "Can't find user" });
+  }
+
+  if (reporterProfile.ban !== "cool") {
+    return NextResponse.json({ error: "Error" });
+  }
+
+  if (reporterProfile.id === profileId) {
+    return NextResponse.json({ error: "You can't report yourself." });
+  }
+
+  const { data: reportedProfile } = await supabase
+    .from("profiles")
+    .select("id,username,computedUsername,avatar_url")
+    .eq("id", profileId)
+    .single();
+
+  if (!reportedProfile) {
+    return NextResponse.json({ error: "Player not found." });
+  }
+
+  const insertResult = await supabase
+    .from("profileReports")
+    .insert({
+      reporter: reporterProfile.id,
+      reported: reportedProfile.id,
+      description: trimmedDescription,
+    })
+    .select("id,created_at")
+    .single();
+
+  if (insertResult.error) {
+    return NextResponse.json({ error: insertResult.error.message });
+  }
+
+  await postProfileReportWebhook({
+    reportId: insertResult.data.id,
+    reporter: reporterProfile,
+    reported: reportedProfile,
+    description: trimmedDescription,
+    createdAt: insertResult.data.created_at,
+  });
+
+  return NextResponse.json({ id: insertResult.data?.id });
+}

package/index.ts

@@ -624,39 +624,39 @@ export const getBeatmapPageById = handleApi({url:"/api/getBeatmapPageById",...Ge
 // ./api/getBeatmaps.ts API
 
 /*
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    textFilter: z.string().optional(),
-    authorFilter: z.string().optional(),
-    tagsFilter: z.string().optional(),
-    page: z.number().default(1),
-    maxStars: z.number().optional(),
-    minLength: z.number().optional(),
-    maxLength: z.number().optional(),
-    minStars: z.number().optional(),
-    creator: z.number().optional(),
-    status: z.string().optional(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-    total: z.number(),
-    viewPerPage: z.number(),
-    currentPage: z.number(),
-    beatmaps: z
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    textFilter: z.string().optional(),
+    authorFilter: z.string().optional(),
+    tagsFilter: z.string().optional(),
+    page: z.number().default(1),
+    maxStars: z.number().optional(),
+    minLength: z.number().optional(),
+    maxLength: z.number().optional(),
+    minStars: z.number().optional(),
+    creator: z.number().optional(),
+    status: z.string().optional(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    total: z.number(),
+    viewPerPage: z.number(),
+    currentPage: z.number(),
+    beatmaps: z
       .array(
         z.object({
           id: z.number(),
           playcount: z.number().nullable().optional(),
           created_at: z.string().nullable().optional(),
-          difficulty: z.number().nullable().optional(),
-          noteCount: 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(),
+          difficulty: z.number().nullable().optional(),
+          noteCount: 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(),
           ownerAvatar: z.string().nullable().optional(),
@@ -667,7 +667,7 @@ export const Schema = {
         })
       )
       .optional(),
-  }),
+  }),
 };*/
 import { Schema as GetBeatmaps } from "./api/getBeatmaps"
 export { Schema as SchemaGetBeatmaps } from "./api/getBeatmaps"
@@ -773,16 +773,17 @@ export const Schema = {
     collection: z.number(),
   }),
   output: z.object({
-    collection: z.object({
-      title: z.string(),
-      description: z.string(),
-      owner: z.object({
-        id: z.number(),
-        username: z.string(),
-      }),
-      isList: z.boolean(),
-      beatmaps: z.array(
-        z.object({
+    collection: z.object({
+      title: z.string(),
+      description: z.string(),
+      owner: z.object({
+        id: z.number(),
+        username: z.string(),
+        avatar_url: z.string().nullable(),
+      }),
+      isList: z.boolean(),
+      beatmaps: z.array(
+        z.object({
           id: z.number(),
           playcount: z.number().nullable().optional(),
           created_at: z.string().nullable().optional(),
@@ -1348,6 +1349,24 @@ import { Schema as RankMapsArchive } from "./api/rankMapsArchive"
 export { Schema as SchemaRankMapsArchive } from "./api/rankMapsArchive"
 export const rankMapsArchive = handleApi({url:"/api/rankMapsArchive",...RankMapsArchive})
 
+// ./api/reportProfile.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    profileId: z.number(),
+    description: z.string(),
+  }),
+  output: z.strictObject({
+    error: z.string().optional(),
+    id: z.number().optional(),
+  }),
+};*/
+import { Schema as ReportProfile } from "./api/reportProfile"
+export { Schema as SchemaReportProfile } from "./api/reportProfile"
+export const reportProfile = handleApi({url:"/api/reportProfile",...ReportProfile})
+
 // ./api/searchUsers.ts API
 
 /*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "235.0.0",
+  "version": "237.0.0",
   "main": "index.ts",
   "author": "online-contributors-cunev",
   "scripts": {
@@ -10,6 +10,7 @@
     "test": "tsx ./scripts/test.ts",
     "cache:clear-user-scores": "bun run scripts/clear-user-score-cache.ts",
     "db:optimize-user-scores": "bun run scripts/optimize-user-scores-indexes.ts",
+    "db:create-profile-reports": "node scripts/create-profile-reports-table.ts",
     "query-pull": "bun run scripts/pull-queries.ts",
     "query-push": "bun run scripts/deploy-queries.ts",
     "queries:pull": "bun run scripts/pull-queries.ts",

package/types/database.ts

@@ -519,6 +519,45 @@ export type Database = {
         }
         Relationships: []
       }
+      profileReports: {
+        Row: {
+          created_at: string
+          description: string
+          id: number
+          reported: number
+          reporter: number
+        }
+        Insert: {
+          created_at?: string
+          description: string
+          id?: number
+          reported: number
+          reporter: number
+        }
+        Update: {
+          created_at?: string
+          description?: string
+          id?: number
+          reported?: number
+          reporter?: number
+        }
+        Relationships: [
+          {
+            foreignKeyName: "profileReports_reported_fkey"
+            columns: ["reported"]
+            isOneToOne: false
+            referencedRelation: "profiles"
+            referencedColumns: ["id"]
+          },
+          {
+            foreignKeyName: "profileReports_reporter_fkey"
+            columns: ["reporter"]
+            isOneToOne: false
+            referencedRelation: "profiles"
+            referencedColumns: ["id"]
+          },
+        ]
+      }
       profiles: {
         Row: {
           about_me: string | null

package/utils/profileReportWebhook.ts

@@ -0,0 +1,180 @@
+type ProfileReportWebhookProfile = {
+  id: number;
+  username: string | null;
+  computedUsername: string | null;
+  avatar_url: string | null;
+};
+
+function clampText(value: string, maxLength: number) {
+  const sanitized = value.replace(
+    /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g,
+    ""
+  );
+
+  if (sanitized.length <= maxLength) {
+    return sanitized;
+  }
+
+  if (maxLength <= 3) {
+    return sanitized.slice(0, maxLength);
+  }
+
+  return `${sanitized.slice(0, maxLength - 3)}...`;
+}
+
+function getSafeHttpUrl(value: string | null | undefined) {
+  if (!value) {
+    return null;
+  }
+
+  try {
+    const parsed = new URL(value.trim());
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return null;
+    }
+
+    const serialized = parsed.toString();
+    if (serialized.length > 2048) {
+      return null;
+    }
+
+    return serialized;
+  } catch {
+    return null;
+  }
+}
+
+function getDisplayName(profile: ProfileReportWebhookProfile) {
+  return (
+    profile.username ||
+    profile.computedUsername ||
+    `User #${profile.id}`
+  );
+}
+
+function getPlayerUrl(profileId: number) {
+  return `https://www.rhythia.com/player/${profileId}`;
+}
+
+export async function postProfileReportWebhook({
+  reportId,
+  reporter,
+  reported,
+  description,
+  createdAt,
+}: {
+  reportId: number;
+  reporter: ProfileReportWebhookProfile;
+  reported: ProfileReportWebhookProfile;
+  description: string;
+  createdAt?: string;
+}) {
+  const webhookUrl = process.env.DISCORD_REPORT_WEBHOOK_URL;
+  if (!webhookUrl) {
+    return;
+  }
+
+  try {
+    const reporterName = getDisplayName(reporter);
+    const reportedName = getDisplayName(reported);
+    const safeReporterAvatarUrl = getSafeHttpUrl(reporter.avatar_url);
+    const safeReportedAvatarUrl = getSafeHttpUrl(reported.avatar_url);
+
+    const embed: Record<string, any> = {
+      title: clampText(`Profile Report #${reportId}`, 256),
+      description: clampText(description, 4096),
+      color: 0xe67e22,
+      fields: [
+        {
+          name: "Reported Player",
+          value: clampText(
+            `${reportedName} (#${reported.id})\n${getPlayerUrl(reported.id)}`,
+            1024
+          ),
+          inline: true,
+        },
+        {
+          name: "Reporter",
+          value: clampText(
+            `${reporterName} (#${reporter.id})\n${getPlayerUrl(reporter.id)}`,
+            1024
+          ),
+          inline: true,
+        },
+        {
+          name: "Submitted At",
+          value: clampText(
+            new Date(createdAt || Date.now()).toUTCString(),
+            1024
+          ),
+          inline: true,
+        },
+      ],
+      author: {
+        name: clampText(reporterName, 256),
+        url: getPlayerUrl(reporter.id),
+        icon_url: safeReporterAvatarUrl || "https://www.rhythia.com/unkimg.png",
+      },
+      footer: {
+        text: clampText(
+          `Reported player: ${reportedName} | Report ID: ${reportId}`,
+          2048
+        ),
+      },
+    };
+
+    if (safeReportedAvatarUrl) {
+      embed.thumbnail = {
+        url: safeReportedAvatarUrl,
+      };
+    }
+
+    const payload = {
+      content: "New player report submitted.",
+      embeds: [embed],
+    };
+
+    let response = await fetch(webhookUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(payload),
+    });
+
+    if (
+      !response.ok &&
+      response.status === 400 &&
+      payload.embeds?.[0]?.thumbnail?.url
+    ) {
+      const retryPayload = {
+        ...payload,
+        embeds: payload.embeds.map((embed: any) => {
+          const clone = { ...embed };
+          delete clone.thumbnail;
+          return clone;
+        }),
+      };
+
+      response = await fetch(webhookUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(retryPayload),
+      });
+    }
+
+    if (!response.ok) {
+      const responseBody = await response.text();
+      console.log("Discord report webhook failed", {
+        reportId,
+        status: response.status,
+        statusText: response.statusText,
+        responseBody: clampText(responseBody || "-", 4000),
+      });
+    }
+  } catch (error) {
+    console.log("Failed to post profile report webhook", error);
+  }
+}

package/worker.ts

@@ -46,6 +46,7 @@ import { POST as getVideoUploadUrl } from "./api/getVideoUploadUrl";
 import { POST as postBeatmapComment } from "./api/postBeatmapComment";
 import { POST as qualifyMap } from "./api/qualifyMap";
 import { POST as rankMapsArchive } from "./api/rankMapsArchive";
+import { POST as reportProfile } from "./api/reportProfile";
 import { POST as searchUsers } from "./api/searchUsers";
 import { POST as setPasskey } from "./api/setPasskey";
 import { POST as submitScore } from "./api/submitScore";
@@ -113,6 +114,7 @@ const apiRoutes: Record<string, RouteHandler> = {
   "/api/postBeatmapComment": postBeatmapComment,
   "/api/qualifyMap": qualifyMap,
   "/api/rankMapsArchive": rankMapsArchive,
+  "/api/reportProfile": reportProfile,
   "/api/searchUsers": searchUsers,
   "/api/setPasskey": setPasskey,
   "/api/submitScore": submitScore,