rhythia-api 186.0.0 → 187.0.0

package/api/nominateMap.ts

@@ -1,82 +1,82 @@
-import { NextResponse } from "next/server";
-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";
-
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    mapId: z.number(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-  }),
-};
-
-export async function POST(request: Request) {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: validUser,
-    activity: handler,
-  });
-}
-
-export async function handler(data: (typeof Schema)["input"]["_type"]) {
-  const user = (await getUserBySession(data.session)) as User;
-  let { data: queryUserData, error: userError } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("uid", user.id)
-    .single();
-
-  if (!queryUserData) {
-    return NextResponse.json({ error: "Can't find user" });
-  }
-
-  const tags = (queryUserData?.badges || []) as string[];
-
-  if (!tags.includes("RCT")) {
-    return NextResponse.json({ error: "Only RCTs can nominate maps!" });
-  }
-
-  const { data: mapData, error } = await supabase
-    .from("beatmapPages")
-    .select("id,nominations,owner")
-    .eq("id", data.mapId)
-    .single();
-
-  if (!mapData) {
-    return NextResponse.json({ error: "Bad map" });
-  }
-
-  if (mapData.owner == queryUserData.id) {
-    return NextResponse.json({ error: "Can't nominate own map" });
-  }
-
-  if ((mapData.nominations as number[]).includes(queryUserData.id)) {
-    return NextResponse.json({ error: "Already nominated" });
-  }
-
-  const newNominations = [
-    ...(mapData.nominations! as number[]),
-    queryUserData.id,
-  ];
-  if (newNominations.length == 2) {
-    await supabase.from("beatmapPages").upsert({
-      id: data.mapId,
-      nominations: newNominations,
-      status: "RANKED",
-      ranked_at: Date.now(),
-    });
-  } else {
-    await supabase.from("beatmapPages").upsert({
-      id: data.mapId,
-      nominations: newNominations,
-    });
-  }
-
-  return NextResponse.json({});
-}
+import { NextResponse } from "next/server";
+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";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    mapId: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  const user = (await getUserBySession(data.session)) as User;
+  let { data: queryUserData, error: userError } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id)
+    .single();
+
+  if (!queryUserData) {
+    return NextResponse.json({ error: "Can't find user" });
+  }
+
+  const tags = (queryUserData?.badges || []) as string[];
+
+  if (!tags.includes("RCT")) {
+    return NextResponse.json({ error: "Only RCTs can nominate maps!" });
+  }
+
+  const { data: mapData, error } = await supabase
+    .from("beatmapPages")
+    .select("id,nominations,owner")
+    .eq("id", data.mapId)
+    .single();
+
+  if (!mapData) {
+    return NextResponse.json({ error: "Bad map" });
+  }
+
+  if (mapData.owner == queryUserData.id) {
+    return NextResponse.json({ error: "Can't nominate own map" });
+  }
+
+  if ((mapData.nominations as number[]).includes(queryUserData.id)) {
+    return NextResponse.json({ error: "Already nominated" });
+  }
+
+  const newNominations = [
+    ...(mapData.nominations! as number[]),
+    queryUserData.id,
+  ];
+  if (newNominations.length == 2) {
+    await supabase.from("beatmapPages").upsert({
+      id: data.mapId,
+      nominations: newNominations,
+      status: "RANKED",
+      ranked_at: Date.now(),
+    });
+  } else {
+    await supabase.from("beatmapPages").upsert({
+      id: data.mapId,
+      nominations: newNominations,
+    });
+  }
+
+  return NextResponse.json({});
+}

package/api/postBeatmapComment.ts

@@ -1,59 +1,59 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-import { User } from "@supabase/supabase-js";
-import { getUserBySession } from "../utils/getUserBySession";
-
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    page: z.number(),
-    content: z.string(),
-  }),
-  output: z.strictObject({
-    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({
-  session,
-  page,
-  content,
-}: (typeof Schema)["input"]["_type"]): Promise<
-  NextResponse<(typeof Schema)["output"]["_type"]>
-> {
-  const user = (await getUserBySession(session)) as User;
-  let { data: userData, error: userError } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("uid", user.id)
-    .single();
-
-  if (!userData) return NextResponse.json({ error: "No user." });
-  if (userData.ban !== "cool") return NextResponse.json({ error: "Error" });
-
-  const upserted = await supabase
-    .from("beatmapPageComments")
-    .upsert({
-      beatmapPage: page,
-      owner: userData.id,
-      content,
-    })
-    .select("*")
-    .single();
-
-  if (upserted.error?.message.length) {
-    return NextResponse.json({ error: upserted.error.message });
-  }
-  return NextResponse.json({});
-}
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+import { User } from "@supabase/supabase-js";
+import { getUserBySession } from "../utils/getUserBySession";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    page: z.number(),
+    content: z.string(),
+  }),
+  output: z.strictObject({
+    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({
+  session,
+  page,
+  content,
+}: (typeof Schema)["input"]["_type"]): Promise<
+  NextResponse<(typeof Schema)["output"]["_type"]>
+> {
+  const user = (await getUserBySession(session)) as User;
+  let { data: userData, error: userError } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id)
+    .single();
+
+  if (!userData) return NextResponse.json({ error: "No user." });
+  if (userData.ban !== "cool") return NextResponse.json({ error: "Error" });
+
+  const upserted = await supabase
+    .from("beatmapPageComments")
+    .upsert({
+      beatmapPage: page,
+      owner: userData.id,
+      content,
+    })
+    .select("*")
+    .single();
+
+  if (upserted.error?.message.length) {
+    return NextResponse.json({ error: upserted.error.message });
+  }
+  return NextResponse.json({});
+}

package/api/rankMapsArchive.ts

@@ -1,64 +1,64 @@
-import { NextResponse } from "next/server";
-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";
-
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    mapId: z.number(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-  }),
-};
-
-export async function POST(request: Request) {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: validUser,
-    activity: handler,
-  });
-}
-
-export async function handler(data: (typeof Schema)["input"]["_type"]) {
-  const user = (await getUserBySession(data.session)) as User;
-  let { data: queryUserData, error: userError } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("uid", user.id)
-    .single();
-
-  if (!queryUserData) {
-    return NextResponse.json({ error: "Can't find user" });
-  }
-
-  const tags = (queryUserData?.badges || []) as string[];
-
-  if (!tags.includes("Bot")) {
-    return NextResponse.json({ error: "Only Bots can force-rank maps!" });
-  }
-
-  const { data: mapData, error } = await supabase
-    .from("beatmapPages")
-    .select("id,nominations,owner,status")
-    .eq("owner", user.id)
-    .eq("status", "UNRANKED");
-
-  if (!mapData) {
-    return NextResponse.json({ error: "Bad map" });
-  }
-
-  for (const element of mapData) {
-    await supabase.from("beatmapPages").upsert({
-      id: element.id,
-      nominations: [queryUserData.id, queryUserData.id],
-      status: "RANKED",
-    });
-  }
-
-  return NextResponse.json({});
-}
+import { NextResponse } from "next/server";
+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";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    mapId: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  const user = (await getUserBySession(data.session)) as User;
+  let { data: queryUserData, error: userError } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id)
+    .single();
+
+  if (!queryUserData) {
+    return NextResponse.json({ error: "Can't find user" });
+  }
+
+  const tags = (queryUserData?.badges || []) as string[];
+
+  if (!tags.includes("Bot")) {
+    return NextResponse.json({ error: "Only Bots can force-rank maps!" });
+  }
+
+  const { data: mapData, error } = await supabase
+    .from("beatmapPages")
+    .select("id,nominations,owner,status")
+    .eq("owner", user.id)
+    .eq("status", "UNRANKED");
+
+  if (!mapData) {
+    return NextResponse.json({ error: "Bad map" });
+  }
+
+  for (const element of mapData) {
+    await supabase.from("beatmapPages").upsert({
+      id: element.id,
+      nominations: [queryUserData.id, queryUserData.id],
+      status: "RANKED",
+    });
+  }
+
+  return NextResponse.json({});
+}

package/api/searchUsers.ts

@@ -1,56 +1,56 @@
-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: exactUser } = await supabase
-    .from("profiles")
-    .select("id,username")
-    .neq("ban", "excluded")
-    .eq("computedUsername", data.text.toLocaleLowerCase())
-    .single();
-
-  const { data: searchData, error } = await supabase
-    .from("profiles")
-    .select("id,username")
-    .neq("ban", "excluded")
-    .ilike("username", `%${data.text}%`)
-    .limit(10);
-
-  const conjoined = searchData || [];
-
-  if (exactUser && !conjoined.some((user) => user.id === exactUser?.id)) {
-    conjoined.unshift(exactUser);
-  }
-
-  return NextResponse.json({
-    results: conjoined || [],
-  });
-}
+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: exactUser } = await supabase
+    .from("profiles")
+    .select("id,username")
+    .neq("ban", "excluded")
+    .eq("computedUsername", data.text.toLocaleLowerCase())
+    .single();
+
+  const { data: searchData, error } = await supabase
+    .from("profiles")
+    .select("id,username")
+    .neq("ban", "excluded")
+    .ilike("username", `%${data.text}%`)
+    .limit(10);
+
+  const conjoined = searchData || [];
+
+  if (exactUser && !conjoined.some((user) => user.id === exactUser?.id)) {
+    conjoined.unshift(exactUser);
+  }
+
+  return NextResponse.json({
+    results: conjoined || [],
+  });
+}

package/api/setPasskey.ts

@@ -1,59 +1,59 @@
-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";
-import { getUserBySession } from "../utils/getUserBySession";
-import { User } from "@supabase/supabase-js";
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    data: z.object({
-      passkey: z.string(),
-    }),
-  }),
-  output: z.object({
-    error: z.string().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 user = (await getUserBySession(data.session)) as 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];
-  }
-
-  await supabase.from("passkeys").upsert({
-    id: userData.id!,
-    email: user.email!,
-    passkey: data.data.passkey,
-  });
-
-  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";
+import { getUserBySession } from "../utils/getUserBySession";
+import { User } from "@supabase/supabase-js";
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    data: z.object({
+      passkey: z.string(),
+    }),
+  }),
+  output: z.object({
+    error: z.string().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 user = (await getUserBySession(data.session)) as 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];
+  }
+
+  await supabase.from("passkeys").upsert({
+    id: userData.id!,
+    email: user.email!,
+    passkey: data.data.passkey,
+  });
+
+  return NextResponse.json({});
+}