rhythia-api 144.0.0 → 145.0.0

package/index.ts

@@ -1,121 +1,2190 @@
 import { handleApi } from "./handleApi"
 
 // ./api/approveMap.ts API
+
+/*
+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 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})
 
 // ./api/createBeatmap.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    url: z.string(),
+    session: z.string(),
+    updateFlag: z.boolean().optional(),
+  }),
+  output: z.strictObject({
+    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})
 
 // ./api/createBeatmapPage.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+  }),
+  output: z.strictObject({
+    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})
 
 // ./api/deleteBeatmapPage.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    id: z.number(),
+  }),
+  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})
 
 // ./api/editAboutMe.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    data: z.object({
+      about_me: 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"]>> {
+  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})
 
 // ./api/editProfile.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    data: z.object({
+      avatar_url: 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"]>> {
+  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})
 
 // ./api/getAvatarUploadUrl.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    contentLength: z.number(),
+    contentType: z.string(),
+    intrinsicToken: z.string(),
+  }),
+  output: z.strictObject({
+    error: z.string().optional(),
+    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})
 
 // ./api/getBadgedUsers.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    badge: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    leaderboard: z
+      .array(
+        z.object({
+          flag: z.string().nullable(),
+          id: z.number(),
+          username: z.string().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.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})
 
 // ./api/getBeatmapComments.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    page: z.number(),
+  }),
+  output: z.strictObject({
+    error: z.string().optional(),
+    comments: z.array(
+      z.object({
+        beatmapPage: z.number(),
+        content: z.string().nullable(),
+        owner: z.number(),
+        created_at: z.string(),
+        profiles: z.object({
+          avatar_url: z.string().nullable(),
+          username: z.string().nullable(),
+          badges: z.any().nullable(),
+        }),
+      })
+    ),
+  }),
+};
+
+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})
 
 // ./api/getBeatmapPage.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    id: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    beatmap: z
+      .object({
+        id: z.number().nullable().optional(),
+        nominations: z.array(z.number()).nullable().optional(),
+        playcount: z.number().nullable().optional(),
+        created_at: z.string().nullable().optional(),
+        difficulty: z.number().nullable().optional(),
+        noteCount: z.number().nullable().optional(),
+        length: z.number().nullable().optional(),
+        title: z.string().nullable().optional(),
+        ranked: z.boolean().nullable().optional(),
+        beatmapFile: z.string().nullable().optional(),
+        image: z.string().nullable().optional(),
+        starRating: z.number().nullable().optional(),
+        owner: z.number().nullable().optional(),
+        ownerUsername: z.string().nullable().optional(),
+        ownerAvatar: z.string().nullable().optional(),
+        status: z.string().nullable().optional(),
+      })
+      .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})
 
 // ./api/getBeatmapPageById.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    mapId: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    beatmap: z
+      .object({
+        id: z.number().nullable().optional(),
+        nominations: z.array(z.number()).nullable().optional(),
+        playcount: z.number().nullable().optional(),
+        created_at: z.string().nullable().optional(),
+        difficulty: z.number().nullable().optional(),
+        noteCount: z.number().nullable().optional(),
+        length: z.number().nullable().optional(),
+        title: z.string().nullable().optional(),
+        ranked: z.boolean().nullable().optional(),
+        beatmapFile: z.string().nullable().optional(),
+        image: z.string().nullable().optional(),
+        starRating: z.number().nullable().optional(),
+        owner: z.number().nullable().optional(),
+        ownerUsername: z.string().nullable().optional(),
+        ownerAvatar: z.string().nullable().optional(),
+        status: z.string().nullable().optional(),
+      })
+      .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})
 
 // ./api/getBeatmaps.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    textFilter: z.string().optional(),
+    authorFilter: z.string().optional(),
+    tagsFilter: z.string().optional(),
+    page: z.number().default(1),
+    maxStars: z.number().optional(),
+    minLength: z.number().optional(),
+    maxLength: z.number().optional(),
+    minStars: z.number().optional(),
+    creator: z.number().optional(),
+    status: z.string().optional(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    total: z.number(),
+    viewPerPage: z.number(),
+    currentPage: z.number(),
+    beatmaps: z
+      .array(
+        z.object({
+          id: z.number(),
+          playcount: z.number().nullable().optional(),
+          created_at: z.string().nullable().optional(),
+          difficulty: z.number().nullable().optional(),
+          noteCount: z.number().nullable().optional(),
+          length: z.number().nullable().optional(),
+          title: z.string().nullable().optional(),
+          ranked: z.boolean().nullable().optional(),
+          beatmapFile: z.string().nullable().optional(),
+          image: z.string().nullable().optional(),
+          starRating: z.number().nullable().optional(),
+          owner: z.number().nullable().optional(),
+          ownerUsername: z.string().nullable().optional(),
+          ownerAvatar: z.string().nullable().optional(),
+          status: z.string().nullable().optional(),
+          tags: z.string().nullable().optional(),
+        })
+      )
+      .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})
 
 // ./api/getLeaderboard.ts API
+
+/*
+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 = 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})
 
 // ./api/getMapUploadUrl.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    mapName: z.string().optional(),
+    session: z.string(),
+    contentLength: z.number(),
+    contentType: z.string(),
+    intrinsicToken: z.string(),
+  }),
+  output: z.strictObject({
+    error: z.string().optional(),
+    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})
 
 // ./api/getProfile.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    id: z.number().nullable().optional(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    user: z
+      .object({
+        about_me: z.string().nullable(),
+        avatar_url: z.string().nullable(),
+        profile_image: z.string().nullable(),
+        badges: z.any().nullable(),
+        created_at: z.number().nullable(),
+        flag: z.string().nullable(),
+        id: z.number(),
+        uid: z.string().nullable(),
+        ban: 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 && 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})
 
 // ./api/getPublicStats.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({}),
+  output: z.object({
+    profiles: z.number(),
+    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})
 
 // ./api/getScore.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    id: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    score: z
+      .object({
+        awarded_sp: z.number().nullable(),
+        beatmapHash: z.string().nullable(),
+        created_at: z.string(),
+        id: z.number(),
+        misses: z.number().nullable(),
+        passed: z.boolean().nullable(),
+        songId: z.string().nullable(),
+        userId: z.number().nullable(),
+        beatmapDifficulty: z.number().optional().nullable(),
+        beatmapNotes: z.number().optional().nullable(),
+        beatmapTitle: z.string().optional().nullable(),
+        username: z.string().optional().nullable(),
+        speed: z.number().optional().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 { 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})
 
 // ./api/getUserScores.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    id: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    lastDay: z
+      .array(
+        z.object({
+          awarded_sp: z.number().nullable(),
+          beatmapHash: z.string().nullable(),
+          created_at: z.string(),
+          id: z.number(),
+          misses: z.number().nullable(),
+          passed: z.boolean().nullable(),
+          songId: z.string().nullable(),
+          userId: z.number().nullable(),
+          beatmapDifficulty: z.number().optional().nullable(),
+          beatmapNotes: z.number().optional().nullable(),
+          beatmapTitle: z.string().optional().nullable(),
+          speed: z.number().optional().nullable(),
+        })
+      )
+      .optional(),
+    top: z
+      .array(
+        z.object({
+          awarded_sp: z.number().nullable(),
+          beatmapHash: z.string().nullable(),
+          created_at: z.string(),
+          id: z.number(),
+          misses: z.number().nullable(),
+          passed: z.boolean().nullable(),
+          rank: z.string().nullable(),
+          songId: z.string().nullable(),
+          userId: z.number().nullable(),
+          beatmapDifficulty: z.number().optional().nullable(),
+          beatmapNotes: z.number().optional().nullable(),
+          beatmapTitle: z.string().optional().nullable(),
+          speed: z.number().optional().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 { 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})
 
 // ./api/nominateMap.ts API
+
+/*
+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 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})
 
 // ./api/postBeatmapComment.ts API
+
+/*
+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 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})
 
 // ./api/rankMapsArchive.ts API
+
+/*
+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 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})
 
 // ./api/searchUsers.ts API
+
+/*
+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("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})
 
 // ./api/submitScore.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    data: z.strictObject({
+      token: z.string(),
+      relayHwid: z.string(),
+      songId: z.string(),
+      misses: z.number(),
+      hits: z.number(),
+      mapHash: z.string(),
+      mapNoteCount: z.number(),
+      speed: z.number(),
+    }),
+  }),
+  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})
 
 // ./api/updateBeatmapPage.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    id: z.number(),
+    beatmapHash: z.string(),
+    tags: z.string(),
+    description: 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,
+  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})