rhythia-api 98.0.0 → 99.0.0

package/.prettierrc.json

@@ -1,6 +1,6 @@
-{
-  "trailingComma": "es5",
-  "tabWidth": 2,
-  "semi": true,
-  "singleQuote": false
-}
+{
+  "trailingComma": "es5",
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": false
+}

package/api/editProfile.ts

@@ -1,74 +1,74 @@
-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.strictObject({
-    session: z.string(),
-    data: z.object({
-      avatar_url: z.string().optional(),
-      about_me: z.string().optional(),
-      username: z.string().optional(),
-    }),
-  }),
-  output: z.object({
-    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(
-  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"] = {
-    id: userData.id,
-    ...data.data,
-  };
-
-  const upsertResult = await supabase
-    .from("profiles")
-    .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({});
-}
+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.strictObject({
+    session: z.string(),
+    data: z.object({
+      avatar_url: z.string().optional(),
+      about_me: z.string().optional(),
+      username: z.string().optional(),
+    }),
+  }),
+  output: z.object({
+    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(
+  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"] = {
+    id: userData.id,
+    ...data.data,
+  };
+
+  const upsertResult = await supabase
+    .from("profiles")
+    .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

@@ -1,99 +1,99 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { getUser, protectedApi } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    page: z.number().default(1),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-    total: z.number(),
-    viewPerPage: z.number(),
-    currentPage: z.number(),
-    userPosition: z.number(),
-    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(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 getLeaderboard(data.page, data.session);
-  return NextResponse.json(result);
-}
-
-const VIEW_PER_PAGE = 100;
-
-export async function getLeaderboard(page = 1, session) {
-  const getUserData = await getUser(session);
-
-  let leaderPosition = 0;
-
-  if (getUserData) {
-    let { data: queryData, error } = await supabase
-      .from("profiles")
-      .select("*")
-      .eq("uid", getUserData.data.user.id)
-      .single();
-
-    if (queryData) {
-      const { count: playersWithMorePoints, error: rankError } = await supabase
-        .from("profiles")
-        .select("*", { count: "exact", head: true })
-        .gt("skill_points", queryData.skill_points);
-
-      leaderPosition = (playersWithMorePoints || 0) + 1;
-    }
-  }
-
-  const startPage = (page - 1) * VIEW_PER_PAGE;
-  const endPage = startPage + VIEW_PER_PAGE - 1;
-  console.log(startPage, endPage);
-  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(startPage, endPage);
-
-  return {
-    total: countQuery.count || 0,
-    viewPerPage: VIEW_PER_PAGE,
-    currentPage: page,
-    userPosition: leaderPosition,
-    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,
-    })),
-  };
-}
+import { NextResponse } from "next/server";
+import z from "zod";
+import { getUser, protectedApi } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    page: z.number().default(1),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    total: z.number(),
+    viewPerPage: z.number(),
+    currentPage: z.number(),
+    userPosition: z.number(),
+    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(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 getLeaderboard(data.page, data.session);
+  return NextResponse.json(result);
+}
+
+const VIEW_PER_PAGE = 100;
+
+export async function getLeaderboard(page = 1, session: string) {
+  const getUserData = await getUser({ session });
+
+  let leaderPosition = 0;
+
+  if (getUserData) {
+    let { data: queryData, error } = await supabase
+      .from("profiles")
+      .select("*")
+      .eq("uid", getUserData.data.user.id)
+      .single();
+
+    if (queryData) {
+      const { count: playersWithMorePoints, error: rankError } = await supabase
+        .from("profiles")
+        .select("*", { count: "exact", head: true })
+        .gt("skill_points", queryData.skill_points);
+
+      leaderPosition = (playersWithMorePoints || 0) + 1;
+    }
+  }
+
+  const startPage = (page - 1) * VIEW_PER_PAGE;
+  const endPage = startPage + VIEW_PER_PAGE - 1;
+  console.log(startPage, endPage);
+  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(startPage, endPage);
+
+  return {
+    total: countQuery.count || 0,
+    viewPerPage: VIEW_PER_PAGE,
+    currentPage: page,
+    userPosition: leaderPosition,
+    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,115 +1,117 @@
-import { geolocation } from "@vercel/edge";
-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.strictObject({
-    session: z.string(),
-    id: z.number().optional(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-    user: z
-      .object({
-        about_me: z.string().nullable(),
-        avatar_url: z.string().nullable(),
-        badges: z.any().nullable(),
-        created_at: z.number().nullable(),
-        flag: z.string().nullable(),
-        id: z.number(),
-        uid: 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(),
-      })
-      .optional(),
-  }),
-};
-
-export async function POST(request: Request): Promise<NextResponse> {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: validUser,
-    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"][] = [];
-
-  // Fetch by id
-  if (data.id !== undefined) {
-    let { data: queryData, error } = await supabase
-      .from("profiles")
-      .select("*")
-      .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 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) {
-      const geo = geolocation(req);
-      const data = await supabase
-        .from("profiles")
-        .upsert({
-          uid: user.id,
-          about_me: "",
-          avatar_url: user.user_metadata.avatar_url,
-          badges: ["Early Bird"],
-          username: user.user_metadata.full_name,
-          flag: (geo.country || "US").toUpperCase(),
-          created_at: Date.now(),
-        })
-        .select();
-
-      profiles = data.data!;
-    } else {
-      profiles = queryData;
-    }
-  }
-
-  const user = profiles[0];
-
-  // 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 })
-    .gt("skill_points", user.skill_points);
-
-  return NextResponse.json({
-    user: {
-      ...user,
-      position: (playersWithMorePoints || 0) + 1,
-    },
-  });
-}
+import { geolocation } from "@vercel/edge";
+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.strictObject({
+    session: z.string(),
+    id: z.number().optional(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    user: z
+      .object({
+        about_me: z.string().nullable(),
+        avatar_url: z.string().nullable(),
+        badges: z.any().nullable(),
+        created_at: z.number().nullable(),
+        flag: z.string().nullable(),
+        id: z.number(),
+        uid: 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(),
+      })
+      .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"][] = [];
+
+  // Fetch by id
+  if (data.id !== undefined) {
+    let { data: queryData, error } = await supabase
+      .from("profiles")
+      .select("*")
+      .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 supabase.auth.getUser(data.session)).data.user;
+
+    if (user) {
+      let { data: queryData, error } = await supabase
+        .from("profiles")
+        .select("*")
+        .eq("uid", user.id);
+
+      console.log(profiles, error);
+      if (!queryData?.length) {
+        const geo = geolocation(req);
+        const data = await supabase
+          .from("profiles")
+          .upsert({
+            uid: user.id,
+            about_me: "",
+            avatar_url: user.user_metadata.avatar_url,
+            badges: ["Early Bird"],
+            username: user.user_metadata.full_name,
+            flag: (geo.country || "US").toUpperCase(),
+            created_at: Date.now(),
+          })
+          .select();
+
+        profiles = data.data!;
+      } else {
+        profiles = queryData;
+      }
+    }
+  }
+
+  const user = profiles[0];
+
+  // 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 })
+    .gt("skill_points", user.skill_points);
+
+  return NextResponse.json({
+    user: {
+      ...user,
+      position: (playersWithMorePoints || 0) + 1,
+    },
+  });
+}