rhythia-api 182.0.0 → 185.0.0

package/api/editProfile.ts

@@ -1,123 +1,123 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { Database } from "../types/database";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-import { getUserBySession } from "../utils/getUserBySession";
-import { User } from "@supabase/supabase-js";
-import validator from "validator";
-import removeZeroWidth from "zero-width";
-
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    data: z.object({
-      avatar_url: z.string().optional(),
-      profile_image: z.string().optional(),
-      username: z.string().optional(),
-    }),
-  }),
-  output: z.object({
-    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(
-  data: (typeof Schema)["input"]["_type"]
-): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
-  if (data.data.username !== undefined && data.data.username.length === 0) {
-    return NextResponse.json(
-      {
-        error: "Username can't be empty",
-      },
-      { status: 404 }
-    );
-  }
-
-  if (data.data.username && data.data.username.length > 20) {
-    return NextResponse.json(
-      {
-        error: "Username too long.",
-      },
-      { status: 404 }
-    );
-  }
-
-  if (validator.trim(data.data.username || "") !== (data.data.username || "")) {
-    return NextResponse.json(
-      {
-        error: "Username can't start or end with spaces.",
-      },
-      { status: 404 }
-    );
-  }
-
-  data.data.username = removeZeroWidth(data.data.username || "");
-
-  const user = (await getUserBySession(data.session)) as User;
-
-  let userData: Database["public"]["Tables"]["profiles"]["Update"];
-
-  // Find user's entry
-  {
-    let { data: queryUserData, error } = await supabase
-      .from("profiles")
-      .select("*")
-      .eq("uid", user.id);
-
-    if (!queryUserData?.length) {
-      return NextResponse.json(
-        {
-          error: "User cannot be retrieved from session",
-        },
-        { status: 404 }
-      );
-    }
-    userData = queryUserData[0];
-  }
-
-  if (
-    userData.ban == "excluded" ||
-    userData.ban == "restricted" ||
-    userData.ban == "silenced"
-  ) {
-    return NextResponse.json(
-      {
-        error:
-          "Silenced, restricted or excluded players can't update their profile.",
-      },
-      { status: 404 }
-    );
-  }
-
-  const upsertPayload: Database["public"]["Tables"]["profiles"]["Update"] = {
-    id: userData.id,
-    computedUsername: data.data.username?.toLowerCase(),
-    ...data.data,
-  };
-
-  const upsertResult = await supabase
-    .from("profiles")
-    .upsert(upsertPayload)
-    .select();
-
-  if (upsertResult.error) {
-    return NextResponse.json(
-      {
-        error: "Can't update, username might be used by someone else!",
-      },
-      { status: 404 }
-    );
-  }
-
-  return NextResponse.json({});
-}
+import { NextResponse } from "next/server";
+import z from "zod";
+import { Database } from "../types/database";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+import { getUserBySession } from "../utils/getUserBySession";
+import { User } from "@supabase/supabase-js";
+import validator from "validator";
+import removeZeroWidth from "zero-width";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    data: z.object({
+      avatar_url: z.string().optional(),
+      profile_image: z.string().optional(),
+      username: z.string().optional(),
+    }),
+  }),
+  output: z.object({
+    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(
+  data: (typeof Schema)["input"]["_type"]
+): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  if (data.data.username !== undefined && data.data.username.length === 0) {
+    return NextResponse.json(
+      {
+        error: "Username can't be empty",
+      },
+      { status: 404 }
+    );
+  }
+
+  if (data.data.username && data.data.username.length > 20) {
+    return NextResponse.json(
+      {
+        error: "Username too long.",
+      },
+      { status: 404 }
+    );
+  }
+
+  if (validator.trim(data.data.username || "") !== (data.data.username || "")) {
+    return NextResponse.json(
+      {
+        error: "Username can't start or end with spaces.",
+      },
+      { status: 404 }
+    );
+  }
+
+  data.data.username = removeZeroWidth(data.data.username || "");
+
+  const user = (await getUserBySession(data.session)) as User;
+
+  let userData: Database["public"]["Tables"]["profiles"]["Update"];
+
+  // Find user's entry
+  {
+    let { data: queryUserData, error } = await supabase
+      .from("profiles")
+      .select("*")
+      .eq("uid", user.id);
+
+    if (!queryUserData?.length) {
+      return NextResponse.json(
+        {
+          error: "User cannot be retrieved from session",
+        },
+        { status: 404 }
+      );
+    }
+    userData = queryUserData[0];
+  }
+
+  if (
+    userData.ban == "excluded" ||
+    userData.ban == "restricted" ||
+    userData.ban == "silenced"
+  ) {
+    return NextResponse.json(
+      {
+        error:
+          "Silenced, restricted or excluded players can't update their profile.",
+      },
+      { status: 404 }
+    );
+  }
+
+  const upsertPayload: Database["public"]["Tables"]["profiles"]["Update"] = {
+    id: userData.id,
+    computedUsername: data.data.username?.toLowerCase(),
+    ...data.data,
+  };
+
+  const upsertResult = await supabase
+    .from("profiles")
+    .upsert(upsertPayload)
+    .select();
+
+  if (upsertResult.error) {
+    return NextResponse.json(
+      {
+        error: "Can't update, username might be used by someone else!",
+      },
+      { status: 404 }
+    );
+  }
+
+  return NextResponse.json({});
+}

package/api/getAvatarUploadUrl.ts

@@ -1,85 +1,85 @@
-import { NextResponse } from "next/server";
-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 "next/server";
+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,
+  });
+}

package/api/getBadgedUsers.ts

@@ -1,56 +1,56 @@
-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({
-    badge: z.string(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-    leaderboard: z
-      .array(
-        z.object({
-          flag: z.string().nullable(),
-          id: z.number(),
-          username: z.string().nullable(),
-        })
-      )
-      .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 getLeaderboard(data.badge);
-  return NextResponse.json(result);
-}
-
-export async function getLeaderboard(badge: string) {
-  let { data: queryData, error } = await supabase
-    .from("profiles")
-    .select("flag,id,username,badges");
-
-  const users = queryData?.filter((e) =>
-    ((e.badges || []) as string[]).includes(badge)
-  );
-
-  return {
-    leaderboard: users?.map((user) => ({
-      flag: user.flag,
-      id: user.id,
-      username: user.username,
-    })),
-  };
-}
+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({
+    badge: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    leaderboard: z
+      .array(
+        z.object({
+          flag: z.string().nullable(),
+          id: z.number(),
+          username: z.string().nullable(),
+        })
+      )
+      .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 getLeaderboard(data.badge);
+  return NextResponse.json(result);
+}
+
+export async function getLeaderboard(badge: string) {
+  let { data: queryData, error } = await supabase
+    .from("profiles")
+    .select("flag,id,username,badges");
+
+  const users = queryData?.filter((e) =>
+    ((e.badges || []) as string[]).includes(badge)
+  );
+
+  return {
+    leaderboard: users?.map((user) => ({
+      flag: user.flag,
+      id: user.id,
+      username: user.username,
+    })),
+  };
+}

package/api/getBeatmapComments.ts

@@ -1,57 +1,57 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-
-export const Schema = {
-  input: z.strictObject({
-    page: z.number(),
-  }),
-  output: z.strictObject({
-    error: z.string().optional(),
-    comments: z.array(
-      z.object({
-        beatmapPage: z.number(),
-        content: z.string().nullable(),
-        owner: z.number(),
-        created_at: z.string(),
-        profiles: z.object({
-          avatar_url: z.string().nullable(),
-          username: z.string().nullable(),
-          badges: z.any().nullable(),
-        }),
-      })
-    ),
-  }),
-};
-
-export async function POST(request: Request): Promise<NextResponse> {
-  return protectedApi({
-    request,
-    schema: Schema,
-    authorization: () => {},
-    activity: handler,
-  });
-}
-
-export async function handler({
-  page,
-}: (typeof Schema)["input"]["_type"]): Promise<
-  NextResponse<(typeof Schema)["output"]["_type"]>
-> {
-  let { data: userData, error: userError } = await supabase
-    .from("beatmapPageComments")
-    .select(
-      `
-      *,
-      profiles!inner(
-          username,
-          avatar_url,
-          badges
-        )
-      `
-    )
-    .eq("beatmapPage", page);
-
-  return NextResponse.json({ comments: userData! });
-}
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({
+    page: z.number(),
+  }),
+  output: z.strictObject({
+    error: z.string().optional(),
+    comments: z.array(
+      z.object({
+        beatmapPage: z.number(),
+        content: z.string().nullable(),
+        owner: z.number(),
+        created_at: z.string(),
+        profiles: z.object({
+          avatar_url: z.string().nullable(),
+          username: z.string().nullable(),
+          badges: z.any().nullable(),
+        }),
+      })
+    ),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler({
+  page,
+}: (typeof Schema)["input"]["_type"]): Promise<
+  NextResponse<(typeof Schema)["output"]["_type"]>
+> {
+  let { data: userData, error: userError } = await supabase
+    .from("beatmapPageComments")
+    .select(
+      `
+      *,
+      profiles!inner(
+          username,
+          avatar_url,
+          badges
+        )
+      `
+    )
+    .eq("beatmapPage", page);
+
+  return NextResponse.json({ comments: userData! });
+}