rhythia-api 177.0.0 → 179.0.0

package/api/createCollection.ts

@@ -37,6 +37,11 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
     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({

package/api/deleteBeatmapPage.ts

@@ -61,6 +61,7 @@ export async function handler({
     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")

package/api/deleteCollection.ts

@@ -0,0 +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({});
+}

package/api/deleteCollectionMap.ts

@@ -0,0 +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({});
+}

package/api/editCollection.ts

@@ -0,0 +1,69 @@
+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 { describe } from "node:test";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    collection: z.number(),
+    title: z.string(),
+    description: 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: 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" });
+  }
+
+  if (data.title.length < 3) {
+    return NextResponse.json({
+      error: "Collection title should be longer than 3",
+    });
+  }
+
+  await supabase.from("beatmapCollections").upsert({
+    id: data.collection,
+    title: data.title,
+    description: data.description,
+    owner: queryUserData.id,
+  });
+  return NextResponse.json({});
+}

package/index.ts

@@ -128,6 +128,39 @@ import { Schema as DeleteBeatmapPage } from "./api/deleteBeatmapPage"
 export { Schema as SchemaDeleteBeatmapPage } from "./api/deleteBeatmapPage"
 export const deleteBeatmapPage = handleApi({url:"/api/deleteBeatmapPage",...DeleteBeatmapPage})
 
+// ./api/deleteCollection.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    collection: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};*/
+import { Schema as DeleteCollection } from "./api/deleteCollection"
+export { Schema as SchemaDeleteCollection } from "./api/deleteCollection"
+export const deleteCollection = handleApi({url:"/api/deleteCollection",...DeleteCollection})
+
+// ./api/deleteCollectionMap.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    collection: z.number(),
+    beatmapPage: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};*/
+import { Schema as DeleteCollectionMap } from "./api/deleteCollectionMap"
+export { Schema as SchemaDeleteCollectionMap } from "./api/deleteCollectionMap"
+export const deleteCollectionMap = handleApi({url:"/api/deleteCollectionMap",...DeleteCollectionMap})
+
 // ./api/editAboutMe.ts API
 
 /*
@@ -166,6 +199,24 @@ import { Schema as EditClan } from "./api/editClan"
 export { Schema as SchemaEditClan } from "./api/editClan"
 export const editClan = handleApi({url:"/api/editClan",...EditClan})
 
+// ./api/editCollection.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    collection: z.number(),
+    title: z.string(),
+    description: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};*/
+import { Schema as EditCollection } from "./api/editCollection"
+export { Schema as SchemaEditCollection } from "./api/editCollection"
+export const editCollection = handleApi({url:"/api/editCollection",...EditCollection})
+
 // ./api/editProfile.ts API
 
 /*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "177.0.0",
+  "version": "179.0.0",
   "main": "index.ts",
   "author": "online-contributors",
   "scripts": {