rhythia-api 187.0.0 → 189.0.0

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/createBeatmap.ts

@@ -7,6 +7,8 @@ import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
 import { rateMap } from "../utils/star-calc";
 import { getUserBySession } from "../utils/getUserBySession";
 import { User } from "@supabase/supabase-js";
+import { NodeHttpHandler } from "@aws-sdk/node-http-handler";
+
 const s3Client = new S3Client({
   region: "auto",
   endpoint: "https://s3.eu-central-003.backblazeb2.com",
@@ -14,8 +16,46 @@ const s3Client = new S3Client({
     secretAccessKey: process.env.SECRET_BUCKET || "",
     accessKeyId: process.env.ACCESS_BUCKET || "",
   },
+  requestChecksumCalculation: "WHEN_REQUIRED",
 });
 
+// Remove ALL validation and checksum middleware
+const middlewareToRemove = [
+  "build:checksum",
+  "build:content-checksum",
+  "build:content-md5",
+  "validate",
+  "validateChecksum",
+];
+
+s3Client.middlewareStack.add(
+  (next) =>
+    async (args): Promise<any> => {
+      const request = args.request as RequestInit;
+
+      // Remove checksum headers
+      const headers = request.headers as Record<string, string>;
+      delete headers["x-amz-checksum-crc32"];
+      delete headers["x-amz-checksum-crc32c"];
+      delete headers["x-amz-checksum-sha1"];
+      delete headers["x-amz-checksum-sha256"];
+      request.headers = headers;
+
+      Object.entries(request.headers).forEach(
+        // @ts-ignore
+        ([key, value]: [string, string]): void => {
+          if (!request.headers) {
+            request.headers = {};
+          }
+          (request.headers as Record<string, string>)[key] = value;
+        }
+      );
+
+      return next(args);
+    },
+  { step: "build", name: "customHeaders" }
+);
+
 export const Schema = {
   input: z.strictObject({
     url: z.string(),

package/api/createInvite.ts

@@ -0,0 +1,66 @@
+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";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    type: z.string(),
+    resourceId: z.string(),
+  }),
+  output: z.object({
+    code: z.string().optional(),
+    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.type !== "clan") {
+    return NextResponse.json({
+      error: "Invites can only be created for clans",
+    });
+  }
+
+  if (data.resourceId !== queryUserData.clan?.toString()) {
+    return NextResponse.json({
+      error: "You can't create invite for a clan that you aren't owner of.",
+    });
+  }
+
+  const invite = short.generate();
+
+  const upsertResult = await supabase
+    .from("invites")
+    .upsert({
+      code: invite,
+      type: "clan",
+      resourceId: data.resourceId,
+    })
+    .select();
+
+  return NextResponse.json({ code: invite });
+}

package/api/getClans.ts

@@ -0,0 +1,45 @@
+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({
+    page: z.number(),
+    session: z.any(),
+  }),
+  output: z.object({
+    clanData: z.array(
+      z.object({
+        id: z.number(),
+        name: z.string(),
+        acronym: z.string().nullable(),
+        avatar_url: z.string().nullable(),
+        description: z.string().nullable(),
+        member_count: z.number(),
+        total_skill_points: z.number(),
+        total_pages: 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 { data: clanData, error } = await supabase.rpc("get_clan_leaderboard", {
+    page_number: data.page,
+    items_per_page: 25,
+  });
+  return NextResponse.json({ clanData, error });
+}

package/api/postBeatmapComment.ts

@@ -42,6 +42,9 @@ export async function handler({
   if (!userData) return NextResponse.json({ error: "No user." });
   if (userData.ban !== "cool") return NextResponse.json({ error: "Error" });
 
+  if (content.length > 256)
+    return NextResponse.json({ error: "Comment exceeds length." });
+
   const upserted = await supabase
     .from("beatmapPageComments")
     .upsert({

package/api/submitScore.ts

@@ -198,7 +198,7 @@ export async function handler({
 
   if (
     beatmaps.starRating &&
-    Math.abs(beatmaps.starRating - data.virtualStars) < 0.01
+    Math.abs(beatmaps.starRating - data.virtualStars) < 0.1
   ) {
     awarded_sp = calculatePerformancePoints(
       data.speed * beatmaps.starRating * multiplierMod,

package/index.ts

@@ -1,5 +1,21 @@
 import { handleApi } from "./handleApi"
 
+// ./api/acceptInvite.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    code: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};*/
+import { Schema as AcceptInvite } from "./api/acceptInvite"
+export { Schema as SchemaAcceptInvite } from "./api/acceptInvite"
+export const acceptInvite = handleApi({url:"/api/acceptInvite",...AcceptInvite})
+
 // ./api/addCollectionMap.ts API
 
 /*
@@ -47,17 +63,7 @@ export const chartPublicStats = handleApi({url:"/api/chartPublicStats",...ChartP
 // ./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(),
-  }),
-};*/
+*/
 import { Schema as CreateBeatmap } from "./api/createBeatmap"
 export { Schema as SchemaCreateBeatmap } from "./api/createBeatmap"
 export const createBeatmap = handleApi({url:"/api/createBeatmap",...CreateBeatmap})
@@ -112,6 +118,24 @@ import { Schema as CreateCollection } from "./api/createCollection"
 export { Schema as SchemaCreateCollection } from "./api/createCollection"
 export const createCollection = handleApi({url:"/api/createCollection",...CreateCollection})
 
+// ./api/createInvite.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    type: z.string(),
+    resourceId: z.string(),
+  }),
+  output: z.object({
+    code: z.string().optional(),
+    error: z.string().optional(),
+  }),
+};*/
+import { Schema as CreateInvite } from "./api/createInvite"
+export { Schema as SchemaCreateInvite } from "./api/createInvite"
+export const createInvite = handleApi({url:"/api/createInvite",...CreateInvite})
+
 // ./api/deleteBeatmapPage.ts API
 
 /*
@@ -500,6 +524,34 @@ import { Schema as GetClan } from "./api/getClan"
 export { Schema as SchemaGetClan } from "./api/getClan"
 export const getClan = handleApi({url:"/api/getClan",...GetClan})
 
+// ./api/getClans.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    page: z.number(),
+    session: z.any(),
+  }),
+  output: z.object({
+    clanData: z.array(
+      z.object({
+        id: z.number(),
+        name: z.string(),
+        acronym: z.string().nullable(),
+        avatar_url: z.string().nullable(),
+        description: z.string().nullable(),
+        member_count: z.number(),
+        total_skill_points: z.number(),
+        total_pages: z.number(),
+      })
+    ),
+    error: z.string().optional(),
+  }),
+};*/
+import { Schema as GetClans } from "./api/getClans"
+export { Schema as SchemaGetClans } from "./api/getClans"
+export const getClans = handleApi({url:"/api/getClans",...GetClans})
+
 // ./api/getCollection.ts API
 
 /*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "187.0.0",
+  "version": "189.0.0",
   "main": "index.ts",
   "author": "online-contributors",
   "scripts": {
@@ -15,6 +15,7 @@
   "dependencies": {
     "@2toad/profanity": "^3.0.0",
     "@aws-sdk/client-s3": "^3.637.0",
+    "@aws-sdk/node-http-handler": "^3.374.0",
     "@aws-sdk/s3-request-presigner": "^3.637.0",
     "@netlify/zip-it-and-ship-it": "^9.37.9",
     "@noble/ciphers": "^1.0.0",
@@ -40,10 +41,12 @@
     "osu-parsers": "^4.1.7",
     "osu-standard-stable": "^5.0.0",
     "sharp": "^0.33.5",
+    "short-uuid": "^5.2.0",
     "simple-git": "^3.25.0",
-    "supabase": "^2.9.6",
+    "supabase": "^2.15.8",
     "tsx": "^4.17.0",
     "utf-8-validate": "^6.0.4",
+    "uuid": "^11.1.0",
     "validator": "^13.12.0",
     "zero-width": "^1.0.29",
     "zod": "^3.23.8"