rhythia-api 186.0.0 → 188.0.0

package/.prettierrc.json

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

package/api/acceptInvite.ts

@@ -0,0 +1,79 @@
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+import { getUserBySession } from "../utils/getUserBySession";
+import { User } from "@supabase/supabase-js";
+import short from "short-uuid";
+import { error } from "console";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    code: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  const user = (await getUserBySession(data.session)) as User;
+  let { data: queryUserData, error: userError } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id)
+    .single();
+
+  if (!queryUserData) {
+    return NextResponse.json({ error: "Can't find user" });
+  }
+
+  let { data: codeData } = await supabase
+    .from("invites")
+    .select("*")
+    .eq("code", data.code)
+    .single();
+
+  if (!codeData || (codeData && codeData.used)) {
+    return NextResponse.json({ error: "Can't find code, or used" });
+  }
+
+  if (codeData.type == "clan") {
+    if (queryUserData.clan) {
+      return NextResponse.json({
+        error: "You can't join another clan while being in a clan",
+      });
+    }
+
+    let { data: queryClanData, error: clanError } = await supabase
+      .from("clans")
+      .select("*")
+      .eq("id", Number(codeData.resourceId))
+      .single();
+
+    if (!queryClanData) {
+      return NextResponse.json({
+        error: "No such clan",
+      });
+    }
+
+    await supabase.from("profiles").upsert({
+      id: queryUserData.id,
+      clan: queryClanData?.id,
+    });
+
+    return NextResponse.json({});
+  }
+
+  return NextResponse.json({ error: "Unknown invite type" });
+}

package/api/addCollectionMap.ts

@@ -1,82 +1,82 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-import { getUserBySession } from "../utils/getUserBySession";
-import { User } from "@supabase/supabase-js";
-
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    collection: z.number(),
-    beatmapPage: z.number(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-  }),
-};
-
-export async function POST(request: Request) {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: validUser,
-    activity: handler,
-  });
-}
-
-export async function handler(data: (typeof Schema)["input"]["_type"]) {
-  const user = (await getUserBySession(data.session)) as User;
-  let { data: queryUserData, error: userError } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("uid", user.id)
-    .single();
-
-  if (!queryUserData) {
-    return NextResponse.json({ error: "Can't find user" });
-  }
-
-  let { data: queryCollectionRelation, error: collectionRelationError } =
-    await supabase
-      .from("collectionRelations")
-      .select("*")
-      .eq("collection", data.collection)
-      .eq("beatmapPage", data.beatmapPage)
-      .single();
-
-  if (queryCollectionRelation) {
-    return NextResponse.json({ error: "Map already in collection" });
-  }
-
-  let { data: queryCollectionData, error: collectionError } = await supabase
-    .from("beatmapCollections")
-    .select("*")
-    .eq("id", data.collection)
-    .single();
-
-  let { data: queryBeatmapData, error: beatmapData } = await supabase
-    .from("beatmapPages")
-    .select("*")
-    .eq("id", data.beatmapPage)
-    .single();
-
-  if (!queryCollectionData) {
-    return NextResponse.json({ error: "Can't find collection" });
-  }
-
-  if (!queryBeatmapData) {
-    return NextResponse.json({ error: "Can't find beatmap page" });
-  }
-
-  if (queryCollectionData.owner !== queryUserData.id) {
-    return NextResponse.json({ error: "You can't update foreign collections" });
-  }
-
-  await supabase.from("collectionRelations").insert({
-    collection: data.collection,
-    beatmapPage: data.beatmapPage,
-  });
-
-  return NextResponse.json({});
-}
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+import { getUserBySession } from "../utils/getUserBySession";
+import { User } from "@supabase/supabase-js";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    collection: z.number(),
+    beatmapPage: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  const user = (await getUserBySession(data.session)) as User;
+  let { data: queryUserData, error: userError } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id)
+    .single();
+
+  if (!queryUserData) {
+    return NextResponse.json({ error: "Can't find user" });
+  }
+
+  let { data: queryCollectionRelation, error: collectionRelationError } =
+    await supabase
+      .from("collectionRelations")
+      .select("*")
+      .eq("collection", data.collection)
+      .eq("beatmapPage", data.beatmapPage)
+      .single();
+
+  if (queryCollectionRelation) {
+    return NextResponse.json({ error: "Map already in collection" });
+  }
+
+  let { data: queryCollectionData, error: collectionError } = await supabase
+    .from("beatmapCollections")
+    .select("*")
+    .eq("id", data.collection)
+    .single();
+
+  let { data: queryBeatmapData, error: beatmapData } = await supabase
+    .from("beatmapPages")
+    .select("*")
+    .eq("id", data.beatmapPage)
+    .single();
+
+  if (!queryCollectionData) {
+    return NextResponse.json({ error: "Can't find collection" });
+  }
+
+  if (!queryBeatmapData) {
+    return NextResponse.json({ error: "Can't find beatmap page" });
+  }
+
+  if (queryCollectionData.owner !== queryUserData.id) {
+    return NextResponse.json({ error: "You can't update foreign collections" });
+  }
+
+  await supabase.from("collectionRelations").insert({
+    collection: data.collection,
+    beatmapPage: data.beatmapPage,
+  });
+
+  return NextResponse.json({});
+}

package/api/approveMap.ts

@@ -1,78 +1,78 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-import { getUserBySession } from "../utils/getUserBySession";
-import { User } from "@supabase/supabase-js";
-
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    mapId: z.number(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-  }),
-};
-
-export async function POST(request: Request) {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: validUser,
-    activity: handler,
-  });
-}
-
-export async function handler(data: (typeof Schema)["input"]["_type"]) {
-  const user = (await getUserBySession(data.session)) as User;
-  let { data: queryUserData, error: userError } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("uid", user.id)
-    .single();
-
-  if (!queryUserData) {
-    return NextResponse.json({ error: "Can't find user" });
-  }
-
-  const tags = (queryUserData?.badges || []) as string[];
-
-  if (!tags.includes("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",
-    ranked_at: Date.now(),
-  });
-
-  return NextResponse.json({});
-}
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+import { getUserBySession } from "../utils/getUserBySession";
+import { User } from "@supabase/supabase-js";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    mapId: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  const user = (await getUserBySession(data.session)) as User;
+  let { data: queryUserData, error: userError } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id)
+    .single();
+
+  if (!queryUserData) {
+    return NextResponse.json({ error: "Can't find user" });
+  }
+
+  const tags = (queryUserData?.badges || []) as string[];
+
+  if (!tags.includes("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",
+    ranked_at: Date.now(),
+  });
+
+  return NextResponse.json({});
+}

package/api/chartPublicStats.ts

@@ -1,32 +1,32 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-
-export const Schema = {
-  input: z.strictObject({}),
-  output: z.object({}),
-};
-
-export async function POST(request: Request) {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: () => {},
-    activity: handler,
-  });
-}
-
-export async function handler(data: (typeof Schema)["input"]["_type"]) {
-  // 30 minutes activity
-  const countOnline = await supabase
-    .from("profileActivities")
-    .select("*", { count: "exact", head: true })
-    .gt("last_activity", Date.now() - 1800000);
-
-  await supabase.from("chartedValues").insert({
-    type: "online_players",
-    value: countOnline.count,
-  });
-  return NextResponse.json({});
-}
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({}),
+  output: z.object({}),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  // 30 minutes activity
+  const countOnline = await supabase
+    .from("profileActivities")
+    .select("*", { count: "exact", head: true })
+    .gt("last_activity", Date.now() - 1800000);
+
+  await supabase.from("chartedValues").insert({
+    type: "online_players",
+    value: countOnline.count,
+  });
+  return NextResponse.json({});
+}