rhythia-api 146.0.0 → 147.0.0

package/index.ts

@@ -11,68 +11,7 @@ export const Schema = {
   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 supabase.auth.getUser(data.session)).data.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("MMT")) {
-    return NextResponse.json({ error: "Only MMTs can approve 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 approve own map" });
-  }
-
-  if ((mapData.nominations as number[])!.length < 2) {
-    return NextResponse.json({
-      error: "Maps can get approved only if they have 2 nominations",
-    });
-  }
-
-  if ((mapData.nominations as number[]).includes(queryUserData.id)) {
-    return NextResponse.json({
-      error: "Can't nominate and approve",
-    });
-  }
-
-  await supabase.from("beatmapPages").upsert({
-    id: data.mapId,
-    status: "RANKED",
-  });
-
-  return NextResponse.json({});
-}
+*/
 import { Schema as ApproveMap } from "./api/approveMap"
 export { Schema as SchemaApproveMap } from "./api/approveMap"
 export const approveMap = handleApi({url:"/api/approveMap",...ApproveMap})
@@ -90,110 +29,7 @@ export const Schema = {
     hash: z.string().optional(),
     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({
-  url,
-  session,
-  updateFlag,
-}: (typeof Schema)["input"]["_type"]): Promise<
-  NextResponse<(typeof Schema)["output"]["_type"]>
-> {
-  if (!url.startsWith(`https://static.rhythia.com/`))
-    return NextResponse.json({ error: "Invalid url" });
-
-  const request = await fetch(url);
-  const bytes = await request.arrayBuffer();
-  const parser = new SSPMParser(Buffer.from(bytes));
-
-  const parsedData = parser.parse();
-  const digested = parsedData.strings.mapID;
-
-  const user = (await supabase.auth.getUser(session)).data.user!;
-  let { data: userData, error: userError } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("uid", user.id)
-    .single();
-
-  if (!userData) {
-    return NextResponse.json({ error: "Bad user" });
-  }
-
-  if (
-    userData.ban == "excluded" ||
-    userData.ban == "restricted" ||
-    userData.ban == "silenced"
-  ) {
-    return NextResponse.json(
-      {
-        error:
-          "Silenced, restricted or excluded players can't update their profile.",
-      },
-      { status: 404 }
-    );
-  }
-
-  let { data: beatmapPage, error: errorlast } = await supabase
-    .from("beatmapPages")
-    .select(`*`)
-    .eq("latestBeatmapHash", digested)
-    .single();
-
-  if (beatmapPage) {
-    if (!updateFlag) {
-      return NextResponse.json({ error: "Already Exists" });
-    } else if (beatmapPage.owner !== userData.id) {
-      return NextResponse.json({ error: "Already Exists" });
-    }
-  }
-
-  const imgkey = `beatmap-img-${Date.now()}-${digested}`;
-
-  let buffer = Buffer.from([]);
-  try {
-    buffer = await require("sharp")(parsedData.cover)
-      .resize(250)
-      .jpeg({ mozjpeg: true })
-      .toBuffer();
-  } catch (error) {}
-
-  const command = new PutObjectCommand({
-    Bucket: "rhthia-avatars",
-    Key: imgkey,
-    Body: buffer,
-    ContentType: "image/jpeg",
-  });
-
-  await s3Client.send(command);
-  const markers = parsedData.markers.sort((a, b) => a.position - b.position);
-
-  const upserted = await supabase.from("beatmaps").upsert({
-    beatmapHash: digested,
-    title: parsedData.strings.mapName,
-    playcount: 0,
-    difficulty: parsedData.metadata.difficulty,
-    noteCount: parsedData.metadata.noteCount,
-    length: markers[markers.length - 1].position,
-    beatmapFile: url,
-    image: `https://static.rhythia.com/${imgkey}`,
-    starRating: rateMap(parsedData),
-  });
-
-  if (upserted.error?.message.length) {
-    return NextResponse.json({ error: upserted.error.message });
-  }
-  return NextResponse.json({ hash: digested });
-}
+*/
 import { Schema as CreateBeatmap } from "./api/createBeatmap"
 export { Schema as SchemaCreateBeatmap } from "./api/createBeatmap"
 export const createBeatmap = handleApi({url:"/api/createBeatmap",...CreateBeatmap})
@@ -209,54 +45,7 @@ export const Schema = {
     error: z.string().optional(),
     id: z.number().optional(),
   }),
-};
-
-export async function POST(request: Request): Promise<NextResponse> {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: validUser,
-    activity: handler,
-  });
-}
-
-export async function handler({
-  session,
-}: (typeof Schema)["input"]["_type"]): Promise<
-  NextResponse<(typeof Schema)["output"]["_type"]>
-> {
-  const user = (await supabase.auth.getUser(session)).data.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 == "excluded" ||
-    userData.ban == "restricted" ||
-    userData.ban == "silenced"
-  ) {
-    return NextResponse.json(
-      {
-        error:
-          "Silenced, restricted or excluded players can't update their profile.",
-      },
-      { status: 404 }
-    );
-  }
-  
-  const upserted = await supabase
-    .from("beatmapPages")
-    .upsert({
-      owner: userData.id,
-    })
-    .select("*")
-    .single();
-  return NextResponse.json({ id: upserted.data?.id });
-}
+*/
 import { Schema as CreateBeatmapPage } from "./api/createBeatmapPage"
 export { Schema as SchemaCreateBeatmapPage } from "./api/createBeatmapPage"
 export const createBeatmapPage = handleApi({url:"/api/createBeatmapPage",...CreateBeatmapPage})
@@ -272,62 +61,7 @@ export const Schema = {
   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,
-  id,
-}: (typeof Schema)["input"]["_type"]): Promise<
-  NextResponse<(typeof Schema)["output"]["_type"]>
-> {
-  const user = (await supabase.auth.getUser(session)).data.user!;
-  let { data: userData, error: userError } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("uid", user.id)
-    .single();
-
-  let { data: pageData, error: pageError } = await supabase
-    .from("beatmapPages")
-    .select("*")
-    .eq("id", id)
-    .single();
-
-  if (!pageData) return NextResponse.json({ error: "No beatmap." });
-
-  let { data: beatmapData, error: bmPageError } = await supabase
-    .from("beatmaps")
-    .select("*")
-    .eq("beatmapHash", pageData.latestBeatmapHash || "-1-1-1-1")
-    .single();
-
-  if (!userData) return NextResponse.json({ error: "No user." });
-  if (!beatmapData) return NextResponse.json({ error: "No beatmap." });
-
-  if (userData.id !== pageData.owner)
-    return NextResponse.json({ error: "Non-authz user." });
-
-  if (pageData.status !== "UNRANKED")
-    return NextResponse.json({ error: "Only unranked maps can be updated" });
-
-  await supabase.from("beatmapPageComments").delete().eq("beatmapPage", id);
-  await supabase.from("beatmapPages").delete().eq("id", id);
-  await supabase
-    .from("beatmaps")
-    .delete()
-    .eq("beatmapHash", beatmapData.beatmapHash);
-
-  return NextResponse.json({});
-}
+*/
 import { Schema as DeleteBeatmapPage } from "./api/deleteBeatmapPage"
 export { Schema as SchemaDeleteBeatmapPage } from "./api/deleteBeatmapPage"
 export const deleteBeatmapPage = handleApi({url:"/api/deleteBeatmapPage",...DeleteBeatmapPage})
@@ -345,80 +79,7 @@ export const Schema = {
   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"]>> {
-  if (!data.data.about_me) {
-    return NextResponse.json(
-      {
-        error: "Missing body.",
-      },
-      { status: 404 }
-    );
-  }
-
-  if (data.data.about_me.length > 10000) {
-    return NextResponse.json(
-      {
-        error: "Too long.",
-      },
-      { status: 404 }
-    );
-  }
-
-  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,
-    about_me: data.data.about_me,
-  };
-
-  const upsertResult = await supabase
-    .from("profiles")
-    .upsert(upsertPayload)
-    .select();
-
-  if (upsertResult.error) {
-    return NextResponse.json(
-      {
-        error: "Can't update..",
-      },
-      { status: 404 }
-    );
-  }
-
-  return NextResponse.json({});
-}
+*/
 import { Schema as EditAboutMe } from "./api/editAboutMe"
 export { Schema as SchemaEditAboutMe } from "./api/editAboutMe"
 export const editAboutMe = handleApi({url:"/api/editAboutMe",...EditAboutMe})
@@ -437,96 +98,7 @@ export const Schema = {
   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"]>> {
-  if (data.data.username !== undefined && data.data.username.length === 0) {
-    return NextResponse.json(
-      {
-        error: "Username can't be empty",
-      },
-      { status: 404 }
-    );
-  }
-
-  if (data.data.username && data.data.username.length > 20) {
-    return NextResponse.json(
-      {
-        error: "Username too long.",
-      },
-      { status: 404 }
-    );
-  }
-
-  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];
-  }
-
-  if (
-    userData.ban == "excluded" ||
-    userData.ban == "restricted" ||
-    userData.ban == "silenced"
-  ) {
-    return NextResponse.json(
-      {
-        error:
-          "Silenced, restricted or excluded players can't update their profile.",
-      },
-      { status: 404 }
-    );
-  }
-
-  const upsertPayload: Database["public"]["Tables"]["profiles"]["Update"] = {
-    id: userData.id,
-    computedUsername: data.data.username?.toLowerCase(),
-    ...data.data,
-  };
-
-  const upsertResult = await supabase
-    .from("profiles")
-    .upsert(upsertPayload)
-    .select();
-
-  if (upsertResult.error) {
-    return NextResponse.json(
-      {
-        error: "Can't update, username might be used by someone else!",
-      },
-      { status: 404 }
-    );
-  }
-
-  return NextResponse.json({});
-}
+*/
 import { Schema as EditProfile } from "./api/editProfile"
 export { Schema as SchemaEditProfile } from "./api/editProfile"
 export const editProfile = handleApi({url:"/api/editProfile",...EditProfile})
@@ -546,55 +118,7 @@ export const Schema = {
     url: z.string().optional(),
     objectKey: 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,
-  contentLength,
-  contentType,
-  intrinsicToken,
-}: (typeof Schema)["input"]["_type"]): Promise<
-  NextResponse<(typeof Schema)["output"]["_type"]>
-> {
-  const user = (await supabase.auth.getUser(session)).data.user!;
-
-  if (!validateIntrinsicToken(intrinsicToken)) {
-    return NextResponse.json({
-      error: "Invalid intrinsic token",
-    });
-  }
-
-  if (contentLength > 5000000) {
-    return NextResponse.json({
-      error: "Max content length exceeded.",
-    });
-  }
-
-  const key = `user-avatar-${Date.now()}-${user.id}`;
-  const command = new PutObjectCommand({
-    Bucket: "rhthia-avatars",
-    Key: key,
-    ContentLength: contentLength,
-    ContentType: contentType,
-  });
-
-  const presigned = await getSignedUrl(s3Client, command, {
-    expiresIn: 3600,
-  });
-  return NextResponse.json({
-    url: presigned,
-    objectKey: key,
-  });
-}
+*/
 import { Schema as GetAvatarUploadUrl } from "./api/getAvatarUploadUrl"
 export { Schema as SchemaGetAvatarUploadUrl } from "./api/getAvatarUploadUrl"
 export const getAvatarUploadUrl = handleApi({url:"/api/getAvatarUploadUrl",...GetAvatarUploadUrl})
@@ -618,41 +142,7 @@ export const Schema = {
       )
       .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.badge);
-  return NextResponse.json(result);
-}
-
-export async function getLeaderboard(badge: string) {
-  let { data: queryData, error } = await supabase
-    .from("profiles")
-    .select("flag,id,username,badges");
-
-  const users = queryData?.filter((e) =>
-    ((e.badges || []) as string[]).includes(badge)
-  );
-
-  return {
-    leaderboard: users?.map((user) => ({
-      flag: user.flag,
-      id: user.id,
-      username: user.username,
-    })),
-  };
-}
+*/
 import { Schema as GetBadgedUsers } from "./api/getBadgedUsers"
 export { Schema as SchemaGetBadgedUsers } from "./api/getBadgedUsers"
 export const getBadgedUsers = handleApi({url:"/api/getBadgedUsers",...GetBadgedUsers})
@@ -680,38 +170,7 @@ export const Schema = {
       })
     ),
   }),
-};
-
-export async function POST(request: Request): Promise<NextResponse> {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: () => {},
-    activity: handler,
-  });
-}
-
-export async function handler({
-  page,
-}: (typeof Schema)["input"]["_type"]): Promise<
-  NextResponse<(typeof Schema)["output"]["_type"]>
-> {
-  let { data: userData, error: userError } = await supabase
-    .from("beatmapPageComments")
-    .select(
-      `
-      *,
-      profiles!inner(
-          username,
-          avatar_url,
-          badges
-        )
-      `
-    )
-    .eq("beatmapPage", page);
-
-  return NextResponse.json({ comments: userData! });
-}
+*/
 import { Schema as GetBeatmapComments } from "./api/getBeatmapComments"
 export { Schema as SchemaGetBeatmapComments } from "./api/getBeatmapComments"
 export const getBeatmapComments = handleApi({url:"/api/getBeatmapComments",...GetBeatmapComments})
@@ -747,70 +206,7 @@ export const Schema = {
       })
       .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 { 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("id", data.id)
-    .single();
-
-  if (!beatmapPage) return NextResponse.json({});
-
-  return NextResponse.json({
-    beatmap: {
-      playcount: beatmapPage.beatmaps?.playcount,
-      created_at: beatmapPage.created_at,
-      difficulty: beatmapPage.beatmaps?.difficulty,
-      noteCount: beatmapPage.beatmaps?.noteCount,
-      length: beatmapPage.beatmaps?.length,
-      title: beatmapPage.beatmaps?.title,
-      ranked: beatmapPage.beatmaps?.ranked,
-      beatmapFile: beatmapPage.beatmaps?.beatmapFile,
-      image: beatmapPage.beatmaps?.image,
-      starRating: beatmapPage.beatmaps?.starRating,
-      owner: beatmapPage.owner,
-      ownerUsername: beatmapPage.profiles?.username,
-      ownerAvatar: beatmapPage.profiles?.avatar_url,
-      id: beatmapPage.id,
-      status: beatmapPage.status,
-      nominations: beatmapPage.nominations as number[],
-    },
-  });
-}
+*/
 import { Schema as GetBeatmapPage } from "./api/getBeatmapPage"
 export { Schema as SchemaGetBeatmapPage } from "./api/getBeatmapPage"
 export const getBeatmapPage = handleApi({url:"/api/getBeatmapPage",...GetBeatmapPage})
@@ -846,70 +242,7 @@ export const Schema = {
       })
       .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 { 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("latestBeatmapHash", data.mapId)
-    .single();
-
-  if (!beatmapPage) return NextResponse.json({});
-
-  return NextResponse.json({
-    beatmap: {
-      playcount: beatmapPage.beatmaps?.playcount,
-      created_at: beatmapPage.created_at,
-      difficulty: beatmapPage.beatmaps?.difficulty,
-      noteCount: beatmapPage.beatmaps?.noteCount,
-      length: beatmapPage.beatmaps?.length,
-      title: beatmapPage.beatmaps?.title,
-      ranked: beatmapPage.beatmaps?.ranked,
-      beatmapFile: beatmapPage.beatmaps?.beatmapFile,
-      image: beatmapPage.beatmaps?.image,
-      starRating: beatmapPage.beatmaps?.starRating,
-      owner: beatmapPage.owner,
-      ownerUsername: beatmapPage.profiles?.username,
-      ownerAvatar: beatmapPage.profiles?.avatar_url,
-      id: beatmapPage.id,
-      status: beatmapPage.status,
-      nominations: beatmapPage.nominations as number[],
-    },
-  });
-}
+*/
 import { Schema as GetBeatmapPageById } from "./api/getBeatmapPageById"
 export { Schema as SchemaGetBeatmapPageById } from "./api/getBeatmapPageById"
 export const getBeatmapPageById = handleApi({url:"/api/getBeatmapPageById",...GetBeatmapPageById})
@@ -959,118 +292,7 @@ export const Schema = {
       )
       .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 getBeatmaps(data);
-  return NextResponse.json(result);
-}
-
-const VIEW_PER_PAGE = 50;
-
-export async function getBeatmaps(data: (typeof Schema)["input"]["_type"]) {
-  const startPage = (data.page - 1) * VIEW_PER_PAGE;
-  const endPage = startPage + VIEW_PER_PAGE - 1;
-  const countQuery = await supabase
-    .from("beatmapPages")
-    .select("id", { count: "exact", head: true });
-
-  let qry = supabase
-    .from("beatmapPages")
-    .select(
-      `
-        owner,
-        created_at,
-        id,
-        status,
-        tags,
-        beatmaps!inner(
-          playcount,
-          ranked,
-          beatmapFile,
-          image,
-          starRating,
-          difficulty,
-          length,
-          title
-        ),
-        profiles!inner(
-          username
-        )`
-    )
-    .order("created_at", { ascending: false });
-
-  if (data.textFilter) {
-    qry = qry.ilike("beatmaps.title", `%${data.textFilter}%`);
-  }
-
-  if (data.authorFilter) {
-    qry = qry.ilike("profiles.username", `%${data.authorFilter}%`);
-  }
-
-  if (data.tagsFilter) {
-    qry = qry.ilike("tags", `%${data.tagsFilter}%`);
-  }
-
-  if (data.minStars) {
-    qry = qry.gt("beatmaps.starRating", data.minStars);
-  }
-
-  if (data.maxStars) {
-    qry = qry.lt("beatmaps.starRating", data.maxStars);
-  }
-
-  if (data.minLength) {
-    qry = qry.gt("beatmaps.length", data.minLength);
-  }
-
-  if (data.maxLength) {
-    qry = qry.lt("beatmaps.length", data.maxLength);
-  }
-
-  if (data.status) {
-    qry = qry.eq("status", data.status);
-  }
-
-  if (data.creator !== undefined) {
-    qry = qry.eq("owner", data.creator);
-  }
-
-  let queryData = await qry.range(startPage, endPage);
-
-  return {
-    total: countQuery.count || 0,
-    viewPerPage: VIEW_PER_PAGE,
-    currentPage: data.page,
-    beatmaps: queryData.data?.map((beatmapPage) => ({
-      id: beatmapPage.id,
-      tags: beatmapPage.tags,
-      playcount: beatmapPage.beatmaps?.playcount,
-      created_at: beatmapPage.created_at,
-      difficulty: beatmapPage.beatmaps?.difficulty,
-      title: beatmapPage.beatmaps?.title,
-      ranked: beatmapPage.beatmaps?.ranked,
-      length: beatmapPage.beatmaps?.length,
-      beatmapFile: beatmapPage.beatmaps?.beatmapFile,
-      image: beatmapPage.beatmaps?.image,
-      starRating: beatmapPage.beatmaps?.starRating,
-      owner: beatmapPage.owner,
-      status: beatmapPage.status,
-      ownerUsername: beatmapPage.profiles?.username,
-    })),
-  };
-}
+*/
 import { Schema as GetBeatmaps } from "./api/getBeatmaps"
 export { Schema as SchemaGetBeatmaps } from "./api/getBeatmaps"
 export const getBeatmaps = handleApi({url:"/api/getBeatmaps",...GetBeatmaps})
@@ -1102,77 +324,7 @@ export const Schema = {
       )
       .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 = 50;
-
-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;
-  const countQuery = await supabase
-    .from("profiles")
-    .select("ban", { count: "exact", head: true })
-    .neq("ban", "excluded");
-
-  let { data: queryData, error } = await supabase
-    .from("profiles")
-    .select("*")
-    .neq("ban", "excluded")
-    .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 { Schema as GetLeaderboard } from "./api/getLeaderboard"
 export { Schema as SchemaGetLeaderboard } from "./api/getLeaderboard"
 export const getLeaderboard = handleApi({url:"/api/getLeaderboard",...GetLeaderboard})
@@ -1193,62 +345,7 @@ export const Schema = {
     url: z.string().optional(),
     objectKey: z.string().optional(),
   }),
-};
-
-export async function POST(request: Request): Promise<NextResponse> {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: validUser,
-    activity: handler,
-  });
-}
-
-export async function handler({
-  mapName,
-  session,
-  contentLength,
-  contentType,
-  intrinsicToken,
-}: (typeof Schema)["input"]["_type"]): Promise<
-  NextResponse<(typeof Schema)["output"]["_type"]>
-> {
-  const user = (await supabase.auth.getUser(session)).data.user!;
-
-  if (!validateIntrinsicToken(intrinsicToken)) {
-    return NextResponse.json({
-      error: "Invalid intrinsic token",
-    });
-  }
-
-  if (contentLength > 50000000) {
-    return NextResponse.json({
-      error: "Max content length exceeded.",
-    });
-  }
-
-  if (contentType !== "application/octet-stream") {
-    return NextResponse.json({
-      error: "Unnacceptable format",
-    });
-  }
-
-  const key = `rhythia-${mapName ? mapName : user.id}-${Date.now()}.sspm`;
-  const command = new PutObjectCommand({
-    Bucket: "rhthia-avatars",
-    Key: key,
-    ContentLength: contentLength,
-    ContentType: contentType,
-  });
-
-  const presigned = await getSignedUrl(s3Client, command, {
-    expiresIn: 3600,
-  });
-  return NextResponse.json({
-    url: presigned,
-    objectKey: key,
-  });
-}
+*/
 import { Schema as GetMapUploadUrl } from "./api/getMapUploadUrl"
 export { Schema as SchemaGetMapUploadUrl } from "./api/getMapUploadUrl"
 export const getMapUploadUrl = handleApi({url:"/api/getMapUploadUrl",...GetMapUploadUrl})
@@ -1284,97 +381,7 @@ export const Schema = {
       })
       .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 && data.id !== null) {
-    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);
-
-      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();
-
-        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 })
-    .neq("ban", "excluded")
-    .gt("skill_points", user.skill_points);
-
-  return NextResponse.json({
-    user: {
-      ...user,
-      position: (playersWithMorePoints || 0) + 1,
-    },
-  });
-}
+*/
 import { Schema as GetProfile } from "./api/getProfile"
 export { Schema as SchemaGetProfile } from "./api/getProfile"
 export const getProfile = handleApi({url:"/api/getProfile",...GetProfile})
@@ -1389,36 +396,7 @@ export const Schema = {
     beatmaps: z.number(),
     scores: 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 });
-
-  const countScoresQuery = await supabase
-    .from("scores")
-    .select("*", { count: "exact", head: true });
-
-  return NextResponse.json({
-    beatmaps: countBeatmapsQuery.count,
-    profiles: countProfilesQuery.count,
-    scores: countScoresQuery.count,
-  });
-}
+*/
 import { Schema as GetPublicStats } from "./api/getPublicStats"
 export { Schema as SchemaGetPublicStats } from "./api/getPublicStats"
 export const getPublicStats = handleApi({url:"/api/getPublicStats",...GetPublicStats})
@@ -1451,59 +429,7 @@ export const Schema = {
       })
       .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 { data: score, error: errorlast } = await supabase
-    .from("scores")
-    .select(
-      `
-      *,
-      beatmaps (
-        difficulty,
-        noteCount,
-        title
-      ),
-      profiles (
-        username
-      )
-    `
-    )
-    .eq("id", data.id)
-    .single();
-
-  if (!score) return NextResponse.json({});
-
-  return NextResponse.json({
-    score: {
-      created_at: score.created_at,
-      id: score.id,
-      passed: score.passed,
-      userId: score.userId,
-      awarded_sp: score.awarded_sp,
-      beatmapHash: score.beatmapHash,
-      misses: score.misses,
-      songId: score.songId,
-      beatmapDifficulty: score.beatmaps?.difficulty,
-      beatmapNotes: score.beatmaps?.noteCount,
-      beatmapTitle: score.beatmaps?.title,
-      username: score.profiles?.username,
-      speed: score.speed,
-    },
-  });
-}
+*/
 import { Schema as GetScore } from "./api/getScore"
 export { Schema as SchemaGetScore } from "./api/getScore"
 export const getScore = handleApi({url:"/api/getScore",...GetScore})
@@ -1556,107 +482,7 @@ export const Schema = {
       )
       .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 { data: scores1, error: errorlast } = await supabase
-    .from("scores")
-    .select(
-      `
-      *,
-      beatmaps (
-        difficulty,
-        noteCount,
-        title
-      )
-    `
-    )
-    .eq("userId", data.id)
-    .eq("passed", true)
-    .order("created_at", { ascending: false })
-    .limit(10);
-
-  let { data: scores2, error: errorsp } = await supabase
-    .from("scores")
-    .select(
-      `
-      *,
-      beatmaps (
-        difficulty,
-        noteCount,
-        title
-      )
-    `
-    )
-    .eq("userId", data.id)
-    .neq("awarded_sp", 0)
-    .eq("passed", true)
-    .order("awarded_sp", { ascending: false });
-
-  if (scores2 == null) return NextResponse.json({ error: "No scores" });
-
-  let hashMap: Record<string, { awarded_sp: number; score: any }> = {};
-
-  for (const score of scores2) {
-    const { beatmapHash, awarded_sp } = score;
-
-    if (!beatmapHash || !awarded_sp) continue;
-
-    if (!hashMap[beatmapHash] || hashMap[beatmapHash].awarded_sp < awarded_sp) {
-      hashMap[beatmapHash] = { awarded_sp, score };
-    }
-  }
-
-  const values = Object.values(hashMap);
-  let vals = values
-    .sort((a, b) => b.awarded_sp - a.awarded_sp)
-    .slice(0, 10)
-    .map((e) => e.score);
-
-  return NextResponse.json({
-    lastDay: scores1?.map((s) => ({
-      created_at: s.created_at,
-      id: s.id,
-      passed: s.passed,
-      userId: s.userId,
-      awarded_sp: s.awarded_sp,
-      beatmapHash: s.beatmapHash,
-      misses: s.misses,
-      songId: s.songId,
-      beatmapDifficulty: s.beatmaps?.difficulty,
-      beatmapNotes: s.beatmaps?.noteCount,
-      beatmapTitle: s.beatmaps?.title,
-      speed: s.speed,
-    })),
-    top: vals?.map((s) => ({
-      created_at: s.created_at,
-      id: s.id,
-      passed: s.passed,
-      userId: s.userId,
-      awarded_sp: s.awarded_sp,
-      beatmapHash: s.beatmapHash,
-      misses: s.misses,
-      rank: s.rank,
-      songId: s.songId,
-      beatmapDifficulty: s.beatmaps?.difficulty,
-      beatmapNotes: s.beatmaps?.noteCount,
-      beatmapTitle: s.beatmaps?.title,
-      speed: s.speed,
-    })),
-  });
-}
+*/
 import { Schema as GetUserScores } from "./api/getUserScores"
 export { Schema as SchemaGetUserScores } from "./api/getUserScores"
 export const getUserScores = handleApi({url:"/api/getUserScores",...GetUserScores})
@@ -1672,60 +498,7 @@ export const Schema = {
   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 supabase.auth.getUser(data.session)).data.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" });
-  }
-
-  await supabase.from("beatmapPages").upsert({
-    id: data.mapId,
-    nominations: [...(mapData.nominations! as number[]), queryUserData.id],
-  });
-
-  return NextResponse.json({});
-}
+*/
 import { Schema as NominateMap } from "./api/nominateMap"
 export { Schema as SchemaNominateMap } from "./api/nominateMap"
 export const nominateMap = handleApi({url:"/api/nominateMap",...NominateMap})
@@ -1742,48 +515,7 @@ export const Schema = {
   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 supabase.auth.getUser(session)).data.user!;
-  let { data: userData, error: userError } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("uid", user.id)
-    .single();
-
-  if (!userData) return NextResponse.json({ error: "No user." });
-
-  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 { Schema as PostBeatmapComment } from "./api/postBeatmapComment"
 export { Schema as SchemaPostBeatmapComment } from "./api/postBeatmapComment"
 export const postBeatmapComment = handleApi({url:"/api/postBeatmapComment",...PostBeatmapComment})
@@ -1799,55 +531,7 @@ export const Schema = {
   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 supabase.auth.getUser(data.session)).data.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 { Schema as RankMapsArchive } from "./api/rankMapsArchive"
 export { Schema as SchemaRankMapsArchive } from "./api/rankMapsArchive"
 export const rankMapsArchive = handleApi({url:"/api/rankMapsArchive",...RankMapsArchive})
@@ -1870,28 +554,7 @@ export const Schema = {
       )
       .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("id,username")
-    .neq("ban", "excluded")
-    .ilike("username", `%${data.text}%`)
-    .limit(10);
-  return NextResponse.json({
-    results: searchData || [],
-  });
-}
+*/
 import { Schema as SearchUsers } from "./api/searchUsers"
 export { Schema as SchemaSearchUsers } from "./api/searchUsers"
 export const searchUsers = handleApi({url:"/api/searchUsers",...SearchUsers})
@@ -1916,188 +579,7 @@ export const Schema = {
   output: z.object({
     error: z.string().optional(),
   }),
-};
-
-function easeInExpoDeq(x: number) {
-  return x === 0 ? 0 : Math.pow(2, 50 * x - 50);
-}
-
-export function calculatePerformancePoints(
-  starRating: number,
-  accuracy: number
-) {
-  return Math.round(
-    Math.pow((starRating * easeInExpoDeq(accuracy) * 100) / 2, 2) / 1000
-  );
-}
-
-export async function POST(request: Request): Promise<NextResponse> {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: validUser,
-    activity: handler,
-  });
-}
-
-export async function handler({
-  data,
-  session,
-}: (typeof Schema)["input"]["_type"]): Promise<
-  NextResponse<(typeof Schema)["output"]["_type"]>
-> {
-  return NextResponse.json(
-    {
-      error: "Disabled",
-    },
-    { status: 500 }
-  );
-  const user = (await supabase.auth.getUser(session)).data.user!;
-
-  let { data: userData, error: userError } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("uid", user.id)
-    .single();
-
-  if (!userData)
-    return NextResponse.json(
-      {
-        error: "User doesn't exist",
-      },
-      { status: 500 }
-    );
-
-  console.log(userData);
-  let { data: beatmaps, error } = await supabase
-    .from("beatmaps")
-    .select("*")
-    .eq("beatmapHash", data.mapHash)
-    .single();
-
-  let { data: beatmapPages, error: bpError } = await supabase
-    .from("beatmapPages")
-    .select("*")
-    .eq("latestBeatmapHash", data.mapHash)
-    .single();
-
-  if (!beatmapPages) {
-    return NextResponse.json(
-      {
-        error: "Map not submitted",
-      },
-      { status: 500 }
-    );
-  }
-
-  if (!beatmaps) {
-    return NextResponse.json(
-      {
-        error: "Map not submitted",
-      },
-      { status: 500 }
-    );
-  }
-
-  if (beatmaps.noteCount !== data.mapNoteCount) {
-    return NextResponse.json(
-      {
-        error: "Wrong map",
-      },
-      { status: 500 }
-    );
-  }
-
-  await supabase.from("beatmaps").upsert({
-    beatmapHash: data.mapHash,
-    playcount: (beatmaps.playcount || 1) + 1,
-  });
-
-  let passed = true;
-
-  // Pass invalidation
-  if (data.misses + data.hits !== beatmaps.noteCount) {
-    passed = false;
-  }
-
-  const accurracy = data.hits / beatmaps.noteCount;
-  let awarded_sp = 0;
-
-  console.log(
-    data.misses + data.hits == beatmaps.noteCount,
-    data.misses + data.hits,
-    beatmaps.noteCount
-  );
-
-  if (beatmaps.starRating) {
-    awarded_sp = calculatePerformancePoints(
-      data.speed * beatmaps.starRating,
-      accurracy
-    );
-  }
-
-  if (beatmapPages.status == "UNRANKED") {
-    awarded_sp = 0;
-  }
-
-  console.log("p1");
-  await supabase.from("scores").upsert({
-    beatmapHash: data.mapHash,
-    replayHwid: data.relayHwid,
-    songId: data.songId,
-    userId: userData.id,
-    passed,
-    misses: data.misses,
-    awarded_sp: Math.round(awarded_sp * 100) / 100,
-    speed: data.speed,
-  });
-  console.log("p2");
-
-  let totalSp = 0;
-  let { data: scores2, error: errorsp } = await supabase
-    .from("scores")
-    .select(`awarded_sp,beatmapHash`)
-    .eq("userId", userData.id)
-    .neq("awarded_sp", 0)
-    .eq("passed", true)
-    .order("awarded_sp", { ascending: false });
-
-  if (scores2 == null) return NextResponse.json({ error: "No scores" });
-
-  let hashMap: Record<string, number> = {};
-
-  for (const score of scores2) {
-    const { beatmapHash, awarded_sp } = score;
-
-    if (!beatmapHash || !awarded_sp) continue;
-
-    if (!hashMap[beatmapHash] || hashMap[beatmapHash] < awarded_sp) {
-      hashMap[beatmapHash] = awarded_sp;
-    }
-  }
-  let weight = 100;
-  const values = Object.values(hashMap);
-  values.sort((a, b) => b - a);
-
-  for (const score of values) {
-    totalSp += ((score || 0) * weight) / 100;
-    weight -= 1;
-
-    if (weight == 0) {
-      break;
-    }
-  }
-
-  await supabase.from("profiles").upsert({
-    id: userData.id,
-    play_count: (userData.play_count || 0) + 1,
-    skill_points: Math.round(totalSp * 100) / 100,
-    squares_hit: (userData.squares_hit || 0) + data.hits,
-  });
-  console.log("p3");
-
-  return NextResponse.json({});
-}
+*/
 import { Schema as SubmitScore } from "./api/submitScore"
 export { Schema as SchemaSubmitScore } from "./api/submitScore"
 export const submitScore = handleApi({url:"/api/submitScore",...SubmitScore})
@@ -2116,75 +598,7 @@ export const Schema = {
   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,
-  beatmapHash,
-  id,
-  description,
-  tags,
-}: (typeof Schema)["input"]["_type"]): Promise<
-  NextResponse<(typeof Schema)["output"]["_type"]>
-> {
-  const user = (await supabase.auth.getUser(session)).data.user!;
-  let { data: userData, error: userError } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("uid", user.id)
-    .single();
-
-  let { data: pageData, error: pageError } = await supabase
-    .from("beatmapPages")
-    .select("*")
-    .eq("id", id)
-    .single();
-
-  let { data: beatmapData, error: bmPageError } = await supabase
-    .from("beatmaps")
-    .select("*")
-    .eq("beatmapHash", beatmapHash)
-    .single();
-
-  if (!userData) return NextResponse.json({ error: "No user." });
-  if (!beatmapData) return NextResponse.json({ error: "No beatmap." });
-
-  if (userData.id !== pageData?.owner)
-    return NextResponse.json({ error: "Non-authz user." });
-
-  if (pageData?.status !== "UNRANKED")
-    return NextResponse.json({ error: "Only unranked maps can be updated" });
-
-  const upserted = await supabase
-    .from("beatmapPages")
-    .upsert({
-      id,
-      latestBeatmapHash: beatmapHash,
-      genre: "",
-      title: beatmapData.title,
-      status: "UNRANKED",
-      owner: userData.id,
-      description,
-      tags,
-      nominations: [],
-    })
-    .select("*")
-    .single();
-
-  if (upserted.error?.message.length) {
-    return NextResponse.json({ error: upserted.error.message });
-  }
-  return NextResponse.json({});
-}
+*/
 import { Schema as UpdateBeatmapPage } from "./api/updateBeatmapPage"
 export { Schema as SchemaUpdateBeatmapPage } from "./api/updateBeatmapPage"
 export const updateBeatmapPage = handleApi({url:"/api/updateBeatmapPage",...UpdateBeatmapPage})