rhythia-api 83.0.0 → 85.0.0

package/.prettierrc.json

@@ -0,0 +1,6 @@
+{
+  "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(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 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,68 +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.strictObject({
-    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,
-    })),
-  });
-}
+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(),
+    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,115 +1,115 @@
-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(res: Response): Promise<NextResponse> {
-  return protectedApi({
-    response: res,
-    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: 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,
+    },
+  });
+}

package/api/searchUsers.ts

@@ -1,46 +1,44 @@
-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({
-    text: z.string(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-    results: z
-      .array(
-        z.object({
-          id: z.number(),
-          username: z.string().nullable(),
-        })
-      )
-      .optional(),
-  }),
-};
-
-export async function POST(res: Response): Promise<NextResponse> {
-  return protectedApi({
-    response: res,
-    schema: Schema,
-    authorization: () => {},
-    activity: handler,
-  });
-}
-
-export async function handler(
-  data: (typeof Schema)["input"]["_type"]
-): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
-  const { data: searchData, error } = await supabase
-    .from("profiles")
-    .select()
-    .ilike("username", `%${data.text}%`)
-    .limit(10);
-  return NextResponse.json({
-    results: (searchData || []).map((data) => ({
-      id: data.id,
-      username: data.username,
-    })),
-  });
-}
+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({
+    text: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    results: z
+      .array(
+        z.object({
+          id: z.number(),
+          username: z.string().nullable(),
+        })
+      )
+      .optional(),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  const { data: searchData, error } = await supabase
+    .from("profiles")
+    .select()
+    .ilike("username", `%${data.text}%`)
+    .limit(10);
+  return NextResponse.json({
+    results: (searchData || []).map((data) => ({
+      id: data.id,
+      username: data.username,
+    })),
+  });
+}