rhythia-api 241.0.0 → 243.0.0

package/api/getAvatarUploadUrl.ts

@@ -1,85 +1,90 @@
-import { NextResponse } from "../utils/response";
-import z from "zod";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-
-import {
-  PutBucketCorsCommand,
-  PutObjectCommand,
-  S3Client,
-} from "@aws-sdk/client-s3";
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
-import { validateIntrinsicToken } from "../utils/validateToken";
-import { getUserBySession } from "../utils/getUserBySession";
-import { User } from "@supabase/supabase-js";
-
-const s3Client = new S3Client({
-  region: "auto",
-  endpoint: "https://s3.eu-central-003.backblazeb2.com",
-  credentials: {
-    secretAccessKey: process.env.SECRET_BUCKET || "",
-    accessKeyId: process.env.ACCESS_BUCKET || "",
-  },
-});
-
-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 getUserBySession(session)) as 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 { NextResponse } from "../utils/response";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { validateIntrinsicToken } from "../utils/validateToken";
+import { getUserBySession } from "../utils/getUserBySession";
+import { User } from "@supabase/supabase-js";
+
+const allowedContentTypes = new Set(["image/jpeg", "image/png", "image/webp"]);
+
+const s3Client = new S3Client({
+  region: "auto",
+  endpoint: "https://s3.eu-central-003.backblazeb2.com",
+  credentials: {
+    secretAccessKey: process.env.SECRET_BUCKET || "",
+    accessKeyId: process.env.ACCESS_BUCKET || "",
+  },
+});
+
+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 getUserBySession(session)) as User;
+
+  if (!validateIntrinsicToken(intrinsicToken)) {
+    return NextResponse.json({
+      error: "Invalid intrinsic token",
+    });
+  }
+
+  if (contentLength > 5000000) {
+    return NextResponse.json({
+      error: "Max content length exceeded.",
+    });
+  }
+
+  if (!allowedContentTypes.has(contentType)) {
+    return NextResponse.json({
+      error: "Unacceptable format",
+    });
+  }
+
+  const key = `user-avatar-${Date.now()}-${user.id}`;
+  const command = new PutObjectCommand({
+    Bucket: "rhthia-avatars",
+    Key: key,
+    ContentLength: contentLength,
+    ContentType: contentType,
+    ContentDisposition: "attachment",
+  });
+
+  const presigned = await getSignedUrl(s3Client, command, {
+    expiresIn: 3600,
+    signableHeaders: new Set(["content-type"]),
+  });
+  return NextResponse.json({
+    url: presigned,
+    objectKey: key,
+  });
+}

package/api/getBeatmapPage.ts

@@ -56,6 +56,7 @@ export const Schema = {
         description: z.string().nullable().optional(),
         tags: z.string().nullable().optional(),
         videoUrl: z.string().nullable().optional(),
+        mapHash: z.string().nullable().optional(),
         vetos: z
           .array(
             z.object({
@@ -173,6 +174,7 @@ export async function handler(
       description: beatmapPage.description,
       tags: beatmapPage.tags,
       videoUrl: beatmapPage.video_url,
+      mapHash: beatmapPage.mapHash,
       vetos: mappedVetos.length > 0 ? mappedVetos : undefined,
     },
   });

package/api/getBeatmapPageById.ts

@@ -53,6 +53,7 @@ export const Schema = {
         qualified: z.boolean().nullable().optional(),
         qualifiedAt: z.string().nullable().optional(),
         videoUrl: z.string().nullable(),
+        mapHash: z.string().nullable().optional(),
         vetos: z
           .array(
             z.object({
@@ -166,6 +167,7 @@ export async function handler(
       qualifiedAt: beatmapPage.qualifiedAt,
       nominations: beatmapPage.nominations as number[],
       videoUrl: beatmapPage.video_url,
+      mapHash: beatmapPage.mapHash,
       vetos: mappedVetos.length > 0 ? mappedVetos : undefined,
     },
   });

package/api/getBeatmaps.ts

@@ -1,197 +1,110 @@
-import { NextResponse } from "../utils/response";
-import z from "zod";
-import { protectedApi } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-
-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(),
-          qualified: z.boolean().nullable().optional(),
-          tags: z.string().nullable().optional(),
-          videoUrl: 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;
-  // status filter is a bit uncanny, we store qualified as a field, but it acts as a status in the UI.
-  const statusFilter = data.status?.toUpperCase();
-  let countQry = supabase
-    .from("beatmapPages")
-    .select(
-      `
-        id,
-        beatmaps!inner(
-          title,
-          starRating,
-          length
-        ),
-        profiles!inner(
-          username
-        )
-      `,
-      { count: "exact", head: true }
-    );
-
-  let qry = supabase.from("beatmapPages").select(
-    `
-        owner,
-        created_at,
-        id,
-        status,
-        qualified,
-        tags,
-        ranked_at,
-        video_url,
-        beatmaps!inner(
-          playcount,
-          ranked,
-          beatmapFile,
-          image,
-          starRating,
-          difficulty,
-          length,
-          title
-        ),
-        profiles!inner(
-          username
-        )`
-  );
-
-  if (statusFilter === "RANKED") {
-    qry = qry.order("ranked_at", { ascending: false });
-  } else {
-    qry = qry.order("created_at", { ascending: false });
-  }
-
-  if (data.textFilter) {
-    qry = qry.ilike("beatmaps.title", `%${data.textFilter}%`);
-    countQry = countQry.ilike("beatmaps.title", `%${data.textFilter}%`);
-  }
-
-  if (data.authorFilter) {
-    qry = qry.ilike("profiles.username", `%${data.authorFilter}%`);
-    countQry = countQry.ilike("profiles.username", `%${data.authorFilter}%`);
-  }
-
-  if (data.tagsFilter) {
-    qry = qry.ilike("tags", `%${data.tagsFilter}%`);
-    countQry = countQry.ilike("tags", `%${data.tagsFilter}%`);
-  }
-
-  if (data.minStars) {
-    qry = qry.gt("beatmaps.starRating", data.minStars);
-    countQry = countQry.gt("beatmaps.starRating", data.minStars);
-  }
-
-  if (data.maxStars) {
-    qry = qry.lt("beatmaps.starRating", data.maxStars);
-    countQry = countQry.lt("beatmaps.starRating", data.maxStars);
-  }
-
-  if (data.minLength) {
-    qry = qry.gt("beatmaps.length", data.minLength);
-    countQry = countQry.gt("beatmaps.length", data.minLength);
-  }
-
-  if (data.maxLength) {
-    qry = qry.lt("beatmaps.length", data.maxLength);
-    countQry = countQry.lt("beatmaps.length", data.maxLength);
-  }
-
-  if (statusFilter === "QUALIFIED") {
-    qry = qry.eq("qualified", true);
-    countQry = countQry.eq("qualified", true);
-  } else if (data.status) {
-    qry = qry.eq("status", data.status);
-    countQry = countQry.eq("status", data.status);
-  }
-
-  if (data.creator !== undefined) {
-    qry = qry.eq("owner", data.creator);
-    countQry = countQry.eq("owner", data.creator);
-  }
-
-  const countQuery = await countQry;
-  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,
-      qualified: beatmapPage.qualified,
-      ownerUsername: beatmapPage.profiles?.username,
-      videoUrl: beatmapPage.video_url,
-    })),
-  };
-}
+import { NextResponse } from "../utils/response";
+import z from "zod";
+import { protectedApi } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+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(),
+          qualified: z.boolean().nullable().optional(),
+          tags: z.string().nullable().optional(),
+          videoUrl: z.string().nullable().optional(),
+          mapHash: 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 { data: beatmaps } = await supabase.rpc("get_beatmaps_v2", {
+    page_number: data.page,
+    items_per_page: VIEW_PER_PAGE,
+    text_filter: data.textFilter || undefined,
+    author_filter: data.authorFilter || undefined,
+    tags_filter: data.tagsFilter || undefined,
+    max_stars: data.maxStars || undefined,
+    min_length: data.minLength || undefined,
+    max_length: data.maxLength || undefined,
+    min_stars: data.minStars || undefined,
+    creator_filter: data.creator,
+    status_filter: data.status || undefined,
+  });
+
+  return {
+    total: beatmaps?.[0]?.total_count || 0,
+    viewPerPage: VIEW_PER_PAGE,
+    currentPage: data.page,
+    beatmaps: beatmaps?.map((beatmapPage) => ({
+      id: beatmapPage.id,
+      tags: beatmapPage.tags,
+      playcount: beatmapPage.playcount,
+      created_at: beatmapPage.created_at,
+      difficulty: beatmapPage.difficulty,
+      title: beatmapPage.title,
+      ranked: beatmapPage.ranked,
+      length: beatmapPage.length,
+      beatmapFile: beatmapPage.beatmap_file,
+      image: beatmapPage.image,
+      starRating: beatmapPage.star_rating,
+      owner: beatmapPage.owner,
+      status: beatmapPage.status,
+      qualified: beatmapPage.qualified,
+      ownerUsername: beatmapPage.owner_username,
+      videoUrl: beatmapPage.video_url,
+      mapHash: beatmapPage.map_hash,
+    })),
+  };
+}

package/api/getCollection.ts

@@ -7,19 +7,22 @@ export const Schema = {
   input: z.strictObject({
     session: z.string(),
     collection: z.number(),
+    page: z.number().optional().default(1),
+    itemsPerPage: z.number().optional().default(30),
   }),
   output: z.object({
-    collection: z.object({
-      title: z.string(),
-      description: z.string(),
-      owner: z.object({
-        id: z.number(),
-        username: z.string(),
-        avatar_url: z.string().nullable(),
-      }),
-      isList: z.boolean(),
-      beatmaps: z.array(
-        z.object({
+    collection: z.object({
+      title: z.string(),
+      description: z.string(),
+      owner: z.object({
+        id: z.number(),
+        username: z.string(),
+        avatar_url: z.string().nullable(),
+      }),
+      isList: z.boolean(),
+      beatmapCount: z.number(),
+      beatmaps: z.array(
+        z.object({
           id: z.number(),
           playcount: z.number().nullable().optional(),
           created_at: z.string().nullable().optional(),
@@ -37,6 +40,7 @@ export const Schema = {
         })
       ),
     }),
+    totalPages: z.number(),
     error: z.string().optional(),
   }),
 };
@@ -51,18 +55,21 @@ export async function POST(request: Request) {
 }
 
 export async function handler(data: (typeof Schema)["input"]["_type"]) {
-  let { data: queryCollectionData, error: collectionError } = await supabase
+  const from = (data.page - 1) * data.itemsPerPage;
+  const to = from + data.itemsPerPage - 1;
+
+  const { data: queryCollectionData } = await supabase
     .from("beatmapCollections")
     .select(
       `
-      *,
-      profiles!inner(
-        id,
-        username,
-        avatar_url
-      )
-      `
-    )
+      *,
+      profiles!inner(
+        id,
+        username,
+        avatar_url
+      )
+      `
+    )
     .eq("id", data.collection)
     .single();
 
@@ -70,7 +77,7 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
     return NextResponse.json({ error: "Can't find collection" });
   }
 
-  let { data: queryBeatmaps, error: beatmapsError } = await supabase
+  const { data: queryBeatmaps, count } = await supabase
     .from("collectionRelations")
     .select(
       `
@@ -95,12 +102,16 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
             username
           )
         )
-      `
+      `,
+      { count: "exact" }
     )
-    .eq("collection", data.collection);
+    .eq("collection", data.collection)
+    .order("sort", { ascending: true })
+    .order("id", { ascending: true })
+    .range(from, to);
 
   const formattedBeatmaps =
-    queryBeatmaps?.map((relation) => ({
+    queryBeatmaps?.map((relation: any) => ({
       id: relation.beatmapPages.id,
       playcount: relation.beatmapPages.beatmaps.playcount,
       created_at: relation.beatmapPages.created_at,
@@ -119,15 +130,17 @@ export async function handler(data: (typeof Schema)["input"]["_type"]) {
 
   return NextResponse.json({
     collection: {
-      owner: {
-        username: queryCollectionData.profiles.username,
-        id: queryCollectionData.profiles.id,
-        avatar_url: queryCollectionData.profiles.avatar_url,
-      },
-      isList: queryCollectionData.is_list,
-      title: queryCollectionData.title,
+      owner: {
+        username: queryCollectionData.profiles.username,
+        id: queryCollectionData.profiles.id,
+        avatar_url: queryCollectionData.profiles.avatar_url,
+      },
+      isList: queryCollectionData.is_list,
+      beatmapCount: count || 0,
+      title: queryCollectionData.title,
       description: queryCollectionData.description,
       beatmaps: formattedBeatmaps,
     },
+    totalPages: Math.max(1, Math.ceil((count || 0) / data.itemsPerPage)),
   });
 }