rhythia-api 186.0.0 → 187.0.0

package/api/createCollection.ts

@@ -1,58 +1,58 @@
-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(),
-    title: z.string(),
-  }),
-  output: z.object({
-    id: z.number(),
-    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" });
-  }
-
-  if (data.title.length < 3) {
-    return NextResponse.json({
-      error: "Collection title should be longer than 3",
-    });
-  }
-  const inserted = await supabase
-    .from("beatmapCollections")
-    .insert({
-      title: data.title,
-      description: "",
-      owner: queryUserData.id,
-    })
-    .select("*")
-    .single();
-
-  return NextResponse.json({
-    id: inserted.data!.id,
-  });
-}
+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(),
+    title: z.string(),
+  }),
+  output: z.object({
+    id: z.number(),
+    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" });
+  }
+
+  if (data.title.length < 3) {
+    return NextResponse.json({
+      error: "Collection title should be longer than 3",
+    });
+  }
+  const inserted = await supabase
+    .from("beatmapCollections")
+    .insert({
+      title: data.title,
+      description: "",
+      owner: queryUserData.id,
+    })
+    .select("*")
+    .single();
+
+  return NextResponse.json({
+    id: inserted.data!.id,
+  });
+}

package/api/deleteBeatmapPage.ts

@@ -1,77 +1,77 @@
-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(),
-    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 getUserBySession(session)) as 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) {
-    const isDev =
-      (userData.badges as string[]).includes("Developer") ||
-      (userData.badges as string[]).includes("Global Moderator");
-
-    if (!isDev) 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("collectionRelations").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 { 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(),
+    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 getUserBySession(session)) as 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) {
+    const isDev =
+      (userData.badges as string[]).includes("Developer") ||
+      (userData.badges as string[]).includes("Global Moderator");
+
+    if (!isDev) 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("collectionRelations").delete().eq("beatmapPage", id);
+  await supabase.from("beatmapPages").delete().eq("id", id);
+  await supabase
+    .from("beatmaps")
+    .delete()
+    .eq("beatmapHash", beatmapData.beatmapHash);
+
+  return NextResponse.json({});
+}

package/api/deleteCollection.ts

@@ -1,59 +1,59 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-import { getUserBySession } from "../utils/getUserBySession";
-import { User } from "@supabase/supabase-js";
-
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    collection: 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: queryCollectionData, error: collectionError } = await supabase
-    .from("beatmapCollections")
-    .select("*")
-    .eq("id", data.collection)
-    .single();
-
-  if (!queryCollectionData) {
-    return NextResponse.json({ error: "Can't find collection" });
-  }
-
-  if (queryCollectionData.owner !== queryUserData.id) {
-    return NextResponse.json({ error: "You can't update foreign collections" });
-  }
-
-  await supabase.from("beatmapCollections").delete().eq("id", data.collection);
-  await supabase
-    .from("collectionRelations")
-    .delete()
-    .eq("collection", data.collection);
-  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(),
+  }),
+  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: queryCollectionData, error: collectionError } = await supabase
+    .from("beatmapCollections")
+    .select("*")
+    .eq("id", data.collection)
+    .single();
+
+  if (!queryCollectionData) {
+    return NextResponse.json({ error: "Can't find collection" });
+  }
+
+  if (queryCollectionData.owner !== queryUserData.id) {
+    return NextResponse.json({ error: "You can't update foreign collections" });
+  }
+
+  await supabase.from("beatmapCollections").delete().eq("id", data.collection);
+  await supabase
+    .from("collectionRelations")
+    .delete()
+    .eq("collection", data.collection);
+  return NextResponse.json({});
+}

package/api/deleteCollectionMap.ts

@@ -1,71 +1,71 @@
-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: 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")
-    .delete()
-    .eq("beatmapPage", data.beatmapPage)
-    .eq("collection", data.collection);
-
-  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: 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")
+    .delete()
+    .eq("beatmapPage", data.beatmapPage)
+    .eq("collection", data.collection);
+
+  return NextResponse.json({});
+}