rhythia-api 183.0.0 → 184.0.0

package/api/getCollection.ts

@@ -1,130 +1,130 @@
-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({
-    session: z.string(),
-    collection: z.number(),
-  }),
-  output: z.object({
-    collection: z.object({
-      title: z.string(),
-      description: z.string(),
-      owner: z.object({
-        id: z.number(),
-        username: z.string(),
-      }),
-      isList: z.boolean(),
-      beatmaps: z.array(
-        z.object({
-          id: z.number(),
-          playcount: z.number().nullable().optional(),
-          created_at: z.string().nullable().optional(),
-          difficulty: 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(),
-          status: z.string().nullable().optional(),
-          tags: z.string().nullable().optional(),
-        })
-      ),
-    }),
-    error: z.string().optional(),
-  }),
-};
-
-export async function POST(request: Request) {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: () => {},
-    activity: handler,
-  });
-}
-
-export async function handler(data: (typeof Schema)["input"]["_type"]) {
-  let { data: queryCollectionData, error: collectionError } = await supabase
-    .from("beatmapCollections")
-    .select(
-      `
-      *,
-      profiles!inner(
-        id,
-        username
-      )
-      `
-    )
-    .eq("id", data.collection)
-    .single();
-
-  if (!queryCollectionData) {
-    return NextResponse.json({ error: "Can't find collection" });
-  }
-
-  let { data: queryBeatmaps, error: beatmapsError } = await supabase
-    .from("collectionRelations")
-    .select(
-      `
-        *,
-        beatmapPages!inner(
-          owner,
-          created_at,
-          id,
-          status,
-          tags,
-          beatmaps!inner(
-            playcount,
-            ranked,
-            beatmapFile,
-            image,
-            starRating,
-            difficulty,
-            length,
-            title
-          ),
-          profiles!inner(
-            username
-          )
-        )
-      `
-    )
-    .eq("collection", data.collection);
-
-  const formattedBeatmaps =
-    queryBeatmaps?.map((relation) => ({
-      id: relation.beatmapPages.id,
-      playcount: relation.beatmapPages.beatmaps.playcount,
-      created_at: relation.beatmapPages.created_at,
-      difficulty: relation.beatmapPages.beatmaps.difficulty,
-      length: relation.beatmapPages.beatmaps.length,
-      title: relation.beatmapPages.beatmaps.title,
-      ranked: relation.beatmapPages.beatmaps.ranked,
-      beatmapFile: relation.beatmapPages.beatmaps.beatmapFile,
-      image: relation.beatmapPages.beatmaps.image,
-      starRating: relation.beatmapPages.beatmaps.starRating,
-      owner: relation.beatmapPages.owner,
-      ownerUsername: relation.beatmapPages.profiles.username,
-      status: relation.beatmapPages.status,
-      tags: relation.beatmapPages.tags,
-    })) || [];
-
-  return NextResponse.json({
-    collection: {
-      owner: {
-        username: queryCollectionData.profiles.username,
-        id: queryCollectionData.profiles.id,
-      },
-      isList: queryCollectionData.is_list,
-      title: queryCollectionData.title,
-      description: queryCollectionData.description,
-      beatmaps: formattedBeatmaps,
-    },
-  });
-}
+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({
+    session: z.string(),
+    collection: z.number(),
+  }),
+  output: z.object({
+    collection: z.object({
+      title: z.string(),
+      description: z.string(),
+      owner: z.object({
+        id: z.number(),
+        username: z.string(),
+      }),
+      isList: z.boolean(),
+      beatmaps: z.array(
+        z.object({
+          id: z.number(),
+          playcount: z.number().nullable().optional(),
+          created_at: z.string().nullable().optional(),
+          difficulty: 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(),
+          status: z.string().nullable().optional(),
+          tags: z.string().nullable().optional(),
+        })
+      ),
+    }),
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  let { data: queryCollectionData, error: collectionError } = await supabase
+    .from("beatmapCollections")
+    .select(
+      `
+      *,
+      profiles!inner(
+        id,
+        username
+      )
+      `
+    )
+    .eq("id", data.collection)
+    .single();
+
+  if (!queryCollectionData) {
+    return NextResponse.json({ error: "Can't find collection" });
+  }
+
+  let { data: queryBeatmaps, error: beatmapsError } = await supabase
+    .from("collectionRelations")
+    .select(
+      `
+        *,
+        beatmapPages!inner(
+          owner,
+          created_at,
+          id,
+          status,
+          tags,
+          beatmaps!inner(
+            playcount,
+            ranked,
+            beatmapFile,
+            image,
+            starRating,
+            difficulty,
+            length,
+            title
+          ),
+          profiles!inner(
+            username
+          )
+        )
+      `
+    )
+    .eq("collection", data.collection);
+
+  const formattedBeatmaps =
+    queryBeatmaps?.map((relation) => ({
+      id: relation.beatmapPages.id,
+      playcount: relation.beatmapPages.beatmaps.playcount,
+      created_at: relation.beatmapPages.created_at,
+      difficulty: relation.beatmapPages.beatmaps.difficulty,
+      length: relation.beatmapPages.beatmaps.length,
+      title: relation.beatmapPages.beatmaps.title,
+      ranked: relation.beatmapPages.beatmaps.ranked,
+      beatmapFile: relation.beatmapPages.beatmaps.beatmapFile,
+      image: relation.beatmapPages.beatmaps.image,
+      starRating: relation.beatmapPages.beatmaps.starRating,
+      owner: relation.beatmapPages.owner,
+      ownerUsername: relation.beatmapPages.profiles.username,
+      status: relation.beatmapPages.status,
+      tags: relation.beatmapPages.tags,
+    })) || [];
+
+  return NextResponse.json({
+    collection: {
+      owner: {
+        username: queryCollectionData.profiles.username,
+        id: queryCollectionData.profiles.id,
+      },
+      isList: queryCollectionData.is_list,
+      title: queryCollectionData.title,
+      description: queryCollectionData.description,
+      beatmaps: formattedBeatmaps,
+    },
+  });
+}

package/api/getCollections.ts

@@ -1,128 +1,126 @@
-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({
-    session: z.string(),
-    page: z.number().optional().default(1),
-    itemsPerPage: z.number().optional().default(10),
-    owner: z.number().optional(), // Added owner field
-  }),
-  output: z.object({
-    collections: z.array(
-      z.object({
-        id: z.number(),
-        title: z.string(),
-        description: z.string(),
-        owner: z.number(),
-        ownerUsername: z.string(),
-        ownerAvatarUrl: z.string(),
-        beatmapCount: z.number(),
-        starRatingDistribution: z.array(
-          z.object({
-            stars: z.number(),
-            count: z.number(),
-          })
-        ),
-        createdAt: z.string(),
-      })
-    ),
-    totalPages: z.number(),
-    error: z.string().optional(),
-  }),
-};
-
-export async function POST(request: Request) {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: () => {},
-    activity: handler,
-  });
-}
-
-export async function handler(data: (typeof Schema)["input"]["_type"]) {
-  const { data: collections, error } = await supabase
-    .rpc("get_collections_v3", {
-      page_number: data.page,
-      items_per_page: data.itemsPerPage,
-      owner_filter: data.owner || undefined, // Added owner_filter parameter
-    })
-    .returns<
-      {
-        id: number;
-        title: string;
-        description: string;
-        created_at: string;
-        owner: number;
-        owner_username: string;
-        owner_avatar_url: string;
-        beatmap_count: number;
-        star1: number;
-        star2: number;
-        star3: number;
-        star4: number;
-        star5: number;
-        star6: number;
-        star7: number;
-        star8: number;
-        star9: number;
-        star10: number;
-        star11: number;
-        star12: number;
-        star13: number;
-        star14: number;
-        star15: number;
-        star16: number;
-        star17: number;
-        star18: number;
-        total_pages: number;
-      }[]
-    >();
-
-  if (error) {
-    return NextResponse.json({ error });
-  }
-
-  // Get the total pages from the first row (all rows will have the same value)
-  const totalPages = collections?.[0]?.total_pages ?? 1;
-
-  const formattedCollections =
-    collections?.map((collection) => ({
-      id: collection.id,
-      title: collection.title,
-      description: collection.description,
-      owner: collection.owner,
-      ownerUsername: collection.owner_username,
-      ownerAvatarUrl: collection.owner_avatar_url,
-      beatmapCount: collection.beatmap_count,
-      starRatingDistribution: [
-        { stars: 1, count: collection.star1 },
-        { stars: 2, count: collection.star2 },
-        { stars: 3, count: collection.star3 },
-        { stars: 4, count: collection.star4 },
-        { stars: 5, count: collection.star5 },
-        { stars: 6, count: collection.star6 },
-        { stars: 7, count: collection.star7 },
-        { stars: 8, count: collection.star8 },
-        { stars: 9, count: collection.star9 },
-        { stars: 10, count: collection.star10 },
-        { stars: 11, count: collection.star11 },
-        { stars: 12, count: collection.star12 },
-        { stars: 13, count: collection.star13 },
-        { stars: 14, count: collection.star14 },
-        { stars: 15, count: collection.star15 },
-        { stars: 16, count: collection.star16 },
-        { stars: 17, count: collection.star17 },
-        { stars: 18, count: collection.star18 },
-      ],
-      createdAt: collection.created_at,
-    })) || [];
-
-  return NextResponse.json({
-    collections: formattedCollections,
-    totalPages,
-  });
-}
+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({
+    session: z.string(),
+    page: z.number().optional().default(1),
+    itemsPerPage: z.number().optional().default(10),
+  }),
+  output: z.object({
+    collections: z.array(
+      z.object({
+        id: z.number(),
+        title: z.string(),
+        description: z.string(),
+        owner: z.number(),
+        ownerUsername: z.string(),
+        ownerAvatarUrl: z.string(),
+        beatmapCount: z.number(),
+        starRatingDistribution: z.array(
+          z.object({
+            stars: z.number(),
+            count: z.number(),
+          })
+        ),
+        createdAt: z.string(),
+      })
+    ),
+    totalPages: z.number(),
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  const { data: collections, error } = await supabase
+    .rpc("get_collections_v2", {
+      page_number: data.page,
+      items_per_page: data.itemsPerPage,
+    })
+    .returns<
+      {
+        id: number;
+        title: string;
+        description: string;
+        created_at: string;
+        owner: number;
+        owner_username: string;
+        owner_avatar_url: string;
+        beatmap_count: number;
+        star1: number;
+        star2: number;
+        star3: number;
+        star4: number;
+        star5: number;
+        star6: number;
+        star7: number;
+        star8: number;
+        star9: number;
+        star10: number;
+        star11: number;
+        star12: number;
+        star13: number;
+        star14: number;
+        star15: number;
+        star16: number;
+        star17: number;
+        star18: number;
+        total_pages: number;
+      }[]
+    >();
+
+  if (error) {
+    return NextResponse.json({ error });
+  }
+
+  // Get the total pages from the first row (all rows will have the same value)
+  const totalPages = collections?.[0]?.total_pages ?? 1;
+
+  const formattedCollections =
+    collections?.map((collection) => ({
+      id: collection.id,
+      title: collection.title,
+      description: collection.description,
+      owner: collection.owner,
+      ownerUsername: collection.owner_username,
+      ownerAvatarUrl: collection.owner_avatar_url,
+      beatmapCount: collection.beatmap_count,
+      starRatingDistribution: [
+        { stars: 1, count: collection.star1 },
+        { stars: 2, count: collection.star2 },
+        { stars: 3, count: collection.star3 },
+        { stars: 4, count: collection.star4 },
+        { stars: 5, count: collection.star5 },
+        { stars: 6, count: collection.star6 },
+        { stars: 7, count: collection.star7 },
+        { stars: 8, count: collection.star8 },
+        { stars: 9, count: collection.star9 },
+        { stars: 10, count: collection.star10 },
+        { stars: 11, count: collection.star11 },
+        { stars: 12, count: collection.star12 },
+        { stars: 13, count: collection.star13 },
+        { stars: 14, count: collection.star14 },
+        { stars: 15, count: collection.star15 },
+        { stars: 16, count: collection.star16 },
+        { stars: 17, count: collection.star17 },
+        { stars: 18, count: collection.star18 },
+      ],
+      createdAt: collection.created_at,
+    })) || [];
+
+  return NextResponse.json({
+    collections: formattedCollections,
+    totalPages,
+  });
+}