rhythia-api 183.0.0 → 184.0.0

package/api/getProfile.ts

@@ -1,146 +1,146 @@
-import { geolocation } from "@vercel/edge";
-import { NextResponse } from "next/server";
-import z from "zod";
-import { Database } from "../types/database";
-import { protectedApi } 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(),
-    id: z.number().nullable().optional(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-    user: z
-      .object({
-        about_me: z.string().nullable(),
-        avatar_url: z.string().nullable(),
-        profile_image: z.string().nullable(),
-        badges: z.any().nullable(),
-        created_at: z.number().nullable(),
-        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(),
-        skill_points: z.number().nullable(),
-        squares_hit: z.number().nullable(),
-        total_score: z.number().nullable(),
-        position: z.number().nullable(),
-        is_online: z.boolean(),
-        clans: z
-          .object({
-            id: z.number(),
-            acronym: z.string(),
-          })
-          .optional()
-          .nullable(),
-      })
-      .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"],
-  req: Request
-): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
-  let profiles: Database["public"]["Tables"]["profiles"]["Row"][] = [];
-  let isOnline = false;
-  // Fetch by id
-  if (data.id !== undefined && data.id !== null) {
-    let { data: queryData, error } = await supabase
-      .from("profiles")
-      .select(`*,clans:clan(id,acronym)`)
-      .eq("id", data.id);
-
-    console.log(profiles, error);
-
-    if (!queryData?.length) {
-      return NextResponse.json(
-        {
-          error: "User not found",
-        },
-        { status: 404 }
-      );
-    }
-
-    profiles = queryData;
-  } else {
-    // Fetch by session id
-    const user = (await getUserBySession(data.session)) as User;
-
-    if (user) {
-      let { data: queryData, error } = await supabase
-        .from("profiles")
-        .select("*")
-        .eq("uid", user.id);
-
-      if (!queryData?.length) {
-        const geo = geolocation(req);
-        const data = await supabase.from("profiles").upsert({
-          uid: user.id,
-          about_me: "",
-          avatar_url:
-            "https://rhthia-avatars.s3.eu-central-003.backblazeb2.com/user-avatar-1725309193296-72002e6b-321c-4f60-a692-568e0e75147d",
-          badges: [],
-          username: `${user.user_metadata.full_name.slice(0, 20)}${Math.round(
-            Math.random() * 900000 + 100000
-          )}`,
-          computedUsername: `${user.user_metadata.full_name.slice(
-            0,
-            20
-          )}${Math.round(Math.random() * 900000 + 100000)}`.toLowerCase(),
-          flag: (geo.country || "US").toUpperCase(),
-          created_at: Date.now(),
-        }).select(`
-          *,clans:clan(id,acronym)`);
-
-        profiles = data.data!;
-      } else {
-        profiles = queryData;
-      }
-    }
-  }
-
-  const user = profiles[0];
-
-  const { data: activityData } = await supabase
-    .from("profileActivities")
-    .select("*")
-    .eq("uid", user.uid || "")
-    .single();
-
-  //last 30 minutes
-  if (activityData && activityData.last_activity) {
-    isOnline = Date.now() - activityData.last_activity < 1800000;
-  }
-
-  // Query to count how many players have more skill points than the specific player
-  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({
-    user: {
-      ...user,
-      position: (playersWithMorePoints || 0) + 1,
-      is_online: isOnline,
-    },
-  });
-}
+import { geolocation } from "@vercel/edge";
+import { NextResponse } from "next/server";
+import z from "zod";
+import { Database } from "../types/database";
+import { protectedApi } 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(),
+    id: z.number().nullable().optional(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    user: z
+      .object({
+        about_me: z.string().nullable(),
+        avatar_url: z.string().nullable(),
+        profile_image: z.string().nullable(),
+        badges: z.any().nullable(),
+        created_at: z.number().nullable(),
+        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(),
+        skill_points: z.number().nullable(),
+        squares_hit: z.number().nullable(),
+        total_score: z.number().nullable(),
+        position: z.number().nullable(),
+        is_online: z.boolean(),
+        clans: z
+          .object({
+            id: z.number(),
+            acronym: z.string(),
+          })
+          .optional()
+          .nullable(),
+      })
+      .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"],
+  req: Request
+): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  let profiles: Database["public"]["Tables"]["profiles"]["Row"][] = [];
+  let isOnline = false;
+  // Fetch by id
+  if (data.id !== undefined && data.id !== null) {
+    let { data: queryData, error } = await supabase
+      .from("profiles")
+      .select(`*,clans:clan(id,acronym)`)
+      .eq("id", data.id);
+
+    console.log(profiles, error);
+
+    if (!queryData?.length) {
+      return NextResponse.json(
+        {
+          error: "User not found",
+        },
+        { status: 404 }
+      );
+    }
+
+    profiles = queryData;
+  } else {
+    // Fetch by session id
+    const user = (await getUserBySession(data.session)) as User;
+
+    if (user) {
+      let { data: queryData, error } = await supabase
+        .from("profiles")
+        .select("*")
+        .eq("uid", user.id);
+
+      if (!queryData?.length) {
+        const geo = geolocation(req);
+        const data = await supabase.from("profiles").upsert({
+          uid: user.id,
+          about_me: "",
+          avatar_url:
+            "https://rhthia-avatars.s3.eu-central-003.backblazeb2.com/user-avatar-1725309193296-72002e6b-321c-4f60-a692-568e0e75147d",
+          badges: [],
+          username: `${user.user_metadata.full_name.slice(0, 20)}${Math.round(
+            Math.random() * 900000 + 100000
+          )}`,
+          computedUsername: `${user.user_metadata.full_name.slice(
+            0,
+            20
+          )}${Math.round(Math.random() * 900000 + 100000)}`.toLowerCase(),
+          flag: (geo.country || "US").toUpperCase(),
+          created_at: Date.now(),
+        }).select(`
+          *,clans:clan(id,acronym)`);
+
+        profiles = data.data!;
+      } else {
+        profiles = queryData;
+      }
+    }
+  }
+
+  const user = profiles[0];
+
+  const { data: activityData } = await supabase
+    .from("profileActivities")
+    .select("*")
+    .eq("uid", user.uid || "")
+    .single();
+
+  //last 30 minutes
+  if (activityData && activityData.last_activity) {
+    isOnline = Date.now() - activityData.last_activity < 1800000;
+  }
+
+  // Query to count how many players have more skill points than the specific player
+  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({
+    user: {
+      ...user,
+      position: (playersWithMorePoints || 0) + 1,
+      is_online: isOnline,
+    },
+  });
+}

package/api/getPublicStats.ts

@@ -1,180 +1,180 @@
-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({
-    profiles: z.number(),
-    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(),
-        nominations: z.array(z.number()).nullable().optional(),
-        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(),
-        owner: z.number().nullable().optional(),
-        ownerUsername: z.string().nullable().optional(),
-        ownerAvatar: z.string().nullable().optional(),
-        status: z.string().nullable().optional(),
-      })
-    ),
-    topUsers: z.array(
-      z.object({
-        username: z.string(),
-        id: z.number(),
-        avatar_url: z.string(),
-        skill_points: z.number(),
-      })
-    ),
-    lastComments: z.array(
-      z.object({
-        owner: z.number(),
-        content: z.string(),
-        username: z.string(),
-        beatmapTitle: z.string(),
-        beatmapPage: z.number(),
-      })
-    ),
-  }),
-};
-
-export async function POST(request: Request) {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: () => {},
-    activity: handler,
-  });
-}
-
-export async function handler(data: (typeof Schema)["input"]["_type"]) {
-  const countProfilesQuery = await supabase
-    .from("profiles")
-    .select("*", { count: "exact", head: true });
-
-  const countBeatmapsQuery = await supabase
-    .from("beatmaps")
-    .select("*", { count: "exact", head: true });
-
-  let { data: beatmapPage, error: errorlast } = await supabase
-    .from("beatmapPages")
-    .select(
-      `
-      *,
-      beatmaps (
-        created_at,
-        playcount,
-        length,
-        ranked,
-        beatmapFile,
-        image,
-        starRating,
-        difficulty,
-        noteCount,
-        title
-      ),
-      profiles (
-        username,
-        avatar_url
-      )
-    `
-    )
-    .eq("status", "RANKED")
-    .order("ranked_at", { ascending: false })
-    .limit(4);
-
-  let { data: topUsers } = await supabase
-    .from("profiles")
-    .select("*")
-    .neq("ban", "excluded")
-    .order("skill_points", { ascending: false })
-    .limit(3);
-
-  let { data: comments } = await supabase
-    .from("beatmapPageComments")
-    .select(
-      `
-      *,
-      beatmapPages!inner(
-        *
-      ),
-      profiles!inner(
-        username
-      )`
-    )
-    .order("created_at", { ascending: false })
-    .limit(5);
-
-  const countScoresQuery = await supabase
-    .from("scores")
-    .select("id", { count: "exact", head: true });
-
-  // 30 minutes activity
-  const countOnline = await supabase
-    .from("profileActivities")
-    .select("*", { count: "exact", head: true })
-    .gt("last_activity", Date.now() - 1800000);
-
-  const countChart = await supabase
-    .from("chartedValues")
-    .select("value")
-    .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,
-      difficulty: e.beatmaps?.difficulty,
-      noteCount: e.beatmaps?.noteCount,
-      length: e.beatmaps?.length,
-      title: e.beatmaps?.title,
-      ranked: e.beatmaps?.ranked,
-      beatmapFile: e.beatmaps?.beatmapFile,
-      image: e.beatmaps?.image,
-      starRating: e.beatmaps?.starRating,
-      owner: e.owner,
-      ownerUsername: e.profiles?.username,
-      ownerAvatar: e.profiles?.avatar_url,
-      id: e.id,
-      status: e.status,
-      nominations: e.nominations as number[],
-    })),
-    topUsers: topUsers?.map((e) => ({
-      username: e.username,
-      id: e.id,
-      avatar_url: e.avatar_url,
-      skill_points: e.skill_points,
-    })),
-    lastComments: comments?.map((e) => ({
-      owner: e.owner,
-      content: e.content,
-      username: e.profiles.username,
-      beatmapTitle: e.beatmapPages.title,
-      beatmapPage: e.beatmapPages.id,
-    })),
-  });
-}
+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({
+    profiles: z.number(),
+    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(),
+        nominations: z.array(z.number()).nullable().optional(),
+        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(),
+        owner: z.number().nullable().optional(),
+        ownerUsername: z.string().nullable().optional(),
+        ownerAvatar: z.string().nullable().optional(),
+        status: z.string().nullable().optional(),
+      })
+    ),
+    topUsers: z.array(
+      z.object({
+        username: z.string(),
+        id: z.number(),
+        avatar_url: z.string(),
+        skill_points: z.number(),
+      })
+    ),
+    lastComments: z.array(
+      z.object({
+        owner: z.number(),
+        content: z.string(),
+        username: z.string(),
+        beatmapTitle: z.string(),
+        beatmapPage: z.number(),
+      })
+    ),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  const countProfilesQuery = await supabase
+    .from("profiles")
+    .select("*", { count: "exact", head: true });
+
+  const countBeatmapsQuery = await supabase
+    .from("beatmaps")
+    .select("*", { count: "exact", head: true });
+
+  let { data: beatmapPage, error: errorlast } = await supabase
+    .from("beatmapPages")
+    .select(
+      `
+      *,
+      beatmaps (
+        created_at,
+        playcount,
+        length,
+        ranked,
+        beatmapFile,
+        image,
+        starRating,
+        difficulty,
+        noteCount,
+        title
+      ),
+      profiles (
+        username,
+        avatar_url
+      )
+    `
+    )
+    .eq("status", "RANKED")
+    .order("ranked_at", { ascending: false })
+    .limit(4);
+
+  let { data: topUsers } = await supabase
+    .from("profiles")
+    .select("*")
+    .neq("ban", "excluded")
+    .order("skill_points", { ascending: false })
+    .limit(3);
+
+  let { data: comments } = await supabase
+    .from("beatmapPageComments")
+    .select(
+      `
+      *,
+      beatmapPages!inner(
+        *
+      ),
+      profiles!inner(
+        username
+      )`
+    )
+    .order("created_at", { ascending: false })
+    .limit(5);
+
+  const countScoresQuery = await supabase
+    .from("scores")
+    .select("id", { count: "exact", head: true });
+
+  // 30 minutes activity
+  const countOnline = await supabase
+    .from("profileActivities")
+    .select("*", { count: "exact", head: true })
+    .gt("last_activity", Date.now() - 1800000);
+
+  const countChart = await supabase
+    .from("chartedValues")
+    .select("value")
+    .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,
+      difficulty: e.beatmaps?.difficulty,
+      noteCount: e.beatmaps?.noteCount,
+      length: e.beatmaps?.length,
+      title: e.beatmaps?.title,
+      ranked: e.beatmaps?.ranked,
+      beatmapFile: e.beatmaps?.beatmapFile,
+      image: e.beatmaps?.image,
+      starRating: e.beatmaps?.starRating,
+      owner: e.owner,
+      ownerUsername: e.profiles?.username,
+      ownerAvatar: e.profiles?.avatar_url,
+      id: e.id,
+      status: e.status,
+      nominations: e.nominations as number[],
+    })),
+    topUsers: topUsers?.map((e) => ({
+      username: e.username,
+      id: e.id,
+      avatar_url: e.avatar_url,
+      skill_points: e.skill_points,
+    })),
+    lastComments: comments?.map((e) => ({
+      owner: e.owner,
+      content: e.content,
+      username: e.profiles.username,
+      beatmapTitle: e.beatmapPages.title,
+      beatmapPage: e.beatmapPages.id,
+    })),
+  });
+}