rhythia-api 75.0.0 → 77.0.0

package/api/editProfile.ts

@@ -31,10 +31,28 @@ export async function handler(
   data: (typeof Schema)["input"]["_type"]
 ): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
   const user = (await supabase.auth.getUser(data.session)).data.user!;
+  let userData: Database["public"]["Tables"]["profiles"]["Update"];
+
+  // Find user's entry
+  {
+    let { data: queryUserData, error } = await supabase
+      .from("profiles")
+      .select("*")
+      .eq("uid", user.id);
+
+    if (!queryUserData?.length) {
+      return NextResponse.json(
+        {
+          error: "User cannot be retrieved from session",
+        },
+        { status: 404 }
+      );
+    }
+    userData = queryUserData[0];
+  }
 
   const upsertPayload: Database["public"]["Tables"]["profiles"]["Update"] = {
-    uid: user.id,
-    flag: "",
+    id: userData.id,
     ...data.data,
   };
 
@@ -43,5 +61,14 @@ export async function handler(
     .upsert(upsertPayload)
     .select();
 
+  if (upsertResult.status == 409) {
+    return NextResponse.json(
+      {
+        error: "Can't update, username might be used by someone else!",
+      },
+      { status: 404 }
+    );
+  }
+
   return NextResponse.json({});
 }

package/api/getLeaderboard.ts

@@ -0,0 +1,68 @@
+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.object({
+    session: z.string(),
+    page: z.number().optional(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    total: z.number().optional(),
+    leaderboard: z
+      .array(
+        z.object({
+          flag: z.string().nullable(),
+          id: z.number(),
+          username: z.string().nullable(),
+          play_count: z.number().nullable(),
+          skill_points: z.number().nullable(),
+          total_score: z.number().nullable(),
+        })
+      )
+      .optional(),
+  }),
+};
+
+export async function POST(res: Response): Promise<NextResponse> {
+  return protectedApi({
+    response: res,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler(
+  data: (typeof Schema)["input"]["_type"]
+): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  const range = [0, 100];
+  if (data.page) {
+    range[0] = 100 * data.page;
+    range[1] = range[0] + 100;
+  }
+
+  const countQuery = await supabase
+    .from("profiles")
+    .select("*", { count: "exact", head: true });
+
+  let { data: queryData, error } = await supabase
+    .from("profiles")
+    .select("*")
+    .order("skill_points", { ascending: false })
+    .range(range[0], range[1]);
+
+  return NextResponse.json({
+    total: countQuery.count || 0,
+    leaderboard: queryData?.map((user) => ({
+      flag: user.flag,
+      id: user.id,
+      play_count: user.play_count,
+      skill_points: user.skill_points,
+      total_score: user.total_score,
+      username: user.username,
+    })),
+  });
+}

package/api/getProfile.ts

@@ -1,12 +1,13 @@
 import { NextResponse } from "next/server";
 import z from "zod";
+import { Database } from "../types/database";
 import { protectedApi, validUser } from "../utils/requestUtils";
 import { supabase } from "../utils/supabase";
 
 export const Schema = {
   input: z.object({
     session: z.string(),
-    id: z.number(),
+    id: z.number().optional(),
   }),
   output: z.object({
     error: z.string().optional(),
@@ -42,20 +43,47 @@ export async function POST(res: Response): Promise<NextResponse> {
 export async function handler(
   data: (typeof Schema)["input"]["_type"]
 ): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
-  let { data: profiles, error } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("id", data.id);
+  let profiles: Database["public"]["Tables"]["profiles"]["Row"][] = [];
 
-  console.log(profiles, error);
+  // Fetch by id
+  if (data.id !== undefined) {
+    let { data: queryData, error } = await supabase
+      .from("profiles")
+      .select("*")
+      .eq("id", data.id);
 
-  if (!profiles?.length) {
-    return NextResponse.json(
-      {
-        error: "User not found",
-      },
-      { status: 404 }
-    );
+    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 supabase.auth.getUser(data.session)).data.user!;
+
+    let { data: queryData, error } = await supabase
+      .from("profiles")
+      .select("*")
+      .eq("uid", user.id);
+
+    console.log(profiles, error);
+
+    if (!queryData?.length) {
+      return NextResponse.json(
+        {
+          error: "User cannot be retrieved from session",
+        },
+        { status: 404 }
+      );
+    }
+    profiles = queryData;
   }
 
   const user = profiles[0];

package/index.ts

@@ -5,6 +5,11 @@ import { Schema as EditProfile } from "./api/editProfile"
 export { Schema as SchemaEditProfile } from "./api/editProfile"
 export const editProfile = handleApi({url:"/api/editProfile",...EditProfile})
 
+// ./api/getLeaderboard.ts API
+import { Schema as GetLeaderboard } from "./api/getLeaderboard"
+export { Schema as SchemaGetLeaderboard } from "./api/getLeaderboard"
+export const getLeaderboard = handleApi({url:"/api/getLeaderboard",...GetLeaderboard})
+
 // ./api/getProfile.ts API
 import { Schema as GetProfile } from "./api/getProfile"
 export { Schema as SchemaGetProfile } from "./api/getProfile"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "75.0.0",
+  "version": "77.0.0",
   "main": "index.ts",
   "scripts": {
     "update": "bun ./scripts/update.ts",