rhythia-api 186.0.0 → 188.0.0

package/api/getLeaderboard.ts

@@ -1,136 +1,136 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi } 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(),
-    page: z.number().default(1),
-    flag: z.string().optional(),
-    spin: z.boolean().default(false),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-    total: z.number(),
-    viewPerPage: z.number(),
-    currentPage: z.number(),
-    userPosition: z.number(),
-    leaderboard: z
-      .array(
-        z.object({
-          flag: z.string().nullable(),
-          id: z.number(),
-          username: z.string().nullable(),
-          play_count: z.number().nullable(),
-          skill_points: z.number().nullable(),
-          spin_skill_points: z.number().nullable(),
-          total_score: z.number().nullable(),
-          clans: z
-            .object({
-              id: z.number(),
-              acronym: z.string(),
-            })
-            .optional()
-            .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.page,
-    data.session,
-    data.spin,
-    data.flag
-  );
-  return NextResponse.json(result);
-}
-
-const VIEW_PER_PAGE = 50;
-
-export async function getLeaderboard(
-  page = 1,
-  session: string,
-  spin: boolean,
-  flag?: string
-) {
-  const getUserData = (await getUserBySession(session)) as User;
-
-  let leaderPosition = 0;
-
-  if (getUserData) {
-    let { data: queryData, error } = await supabase
-      .from("profiles")
-      .select("*")
-      .eq("uid", getUserData.id)
-      .single();
-
-    if (queryData) {
-      const { count: playersWithMorePoints, error: rankError } = await supabase
-        .from("profiles")
-        .select("*", { count: "exact", head: true })
-        .neq("ban", "excluded")
-        .gt("skill_points", queryData.skill_points);
-
-      leaderPosition = (playersWithMorePoints || 0) + 1;
-    }
-  }
-
-  const startPage = (page - 1) * VIEW_PER_PAGE;
-  const endPage = startPage + VIEW_PER_PAGE - 1;
-  const countQuery = await supabase
-    .from("profiles")
-    .select("ban", { count: "exact", head: true })
-    .neq("ban", "excluded");
-
-  let query = supabase
-    .from("profiles")
-    .select("*,clans:clan(id, acronym)")
-    .neq("ban", "excluded");
-
-  if (flag) {
-    query.eq("flag", flag);
-  }
-
-  if (spin) {
-    query.order("spin_skill_points", { ascending: false });
-  } else {
-    query.order("skill_points", { ascending: false });
-  }
-
-  query.range(startPage, endPage);
-
-  let { data: queryData, error } = await query;
-  return {
-    total: countQuery.count || 0,
-    viewPerPage: VIEW_PER_PAGE,
-    currentPage: page,
-    userPosition: leaderPosition,
-    leaderboard: queryData?.map((user) => ({
-      flag: user.flag,
-      id: user.id,
-      play_count: user.play_count,
-      skill_points: user.skill_points,
-      spin_skill_points: user.spin_skill_points,
-      total_score: user.total_score,
-      username: user.username,
-      clans: user.clans as any,
-    })),
-  };
-}
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi } 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(),
+    page: z.number().default(1),
+    flag: z.string().optional(),
+    spin: z.boolean().default(false),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    total: z.number(),
+    viewPerPage: z.number(),
+    currentPage: z.number(),
+    userPosition: z.number(),
+    leaderboard: z
+      .array(
+        z.object({
+          flag: z.string().nullable(),
+          id: z.number(),
+          username: z.string().nullable(),
+          play_count: z.number().nullable(),
+          skill_points: z.number().nullable(),
+          spin_skill_points: z.number().nullable(),
+          total_score: z.number().nullable(),
+          clans: z
+            .object({
+              id: z.number(),
+              acronym: z.string(),
+            })
+            .optional()
+            .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.page,
+    data.session,
+    data.spin,
+    data.flag
+  );
+  return NextResponse.json(result);
+}
+
+const VIEW_PER_PAGE = 50;
+
+export async function getLeaderboard(
+  page = 1,
+  session: string,
+  spin: boolean,
+  flag?: string
+) {
+  const getUserData = (await getUserBySession(session)) as User;
+
+  let leaderPosition = 0;
+
+  if (getUserData) {
+    let { data: queryData, error } = await supabase
+      .from("profiles")
+      .select("*")
+      .eq("uid", getUserData.id)
+      .single();
+
+    if (queryData) {
+      const { count: playersWithMorePoints, error: rankError } = await supabase
+        .from("profiles")
+        .select("*", { count: "exact", head: true })
+        .neq("ban", "excluded")
+        .gt("skill_points", queryData.skill_points);
+
+      leaderPosition = (playersWithMorePoints || 0) + 1;
+    }
+  }
+
+  const startPage = (page - 1) * VIEW_PER_PAGE;
+  const endPage = startPage + VIEW_PER_PAGE - 1;
+  const countQuery = await supabase
+    .from("profiles")
+    .select("ban", { count: "exact", head: true })
+    .neq("ban", "excluded");
+
+  let query = supabase
+    .from("profiles")
+    .select("*,clans:clan(id, acronym)")
+    .neq("ban", "excluded");
+
+  if (flag) {
+    query.eq("flag", flag);
+  }
+
+  if (spin) {
+    query.order("spin_skill_points", { ascending: false });
+  } else {
+    query.order("skill_points", { ascending: false });
+  }
+
+  query.range(startPage, endPage);
+
+  let { data: queryData, error } = await query;
+  return {
+    total: countQuery.count || 0,
+    viewPerPage: VIEW_PER_PAGE,
+    currentPage: page,
+    userPosition: leaderPosition,
+    leaderboard: queryData?.map((user) => ({
+      flag: user.flag,
+      id: user.id,
+      play_count: user.play_count,
+      skill_points: user.skill_points,
+      spin_skill_points: user.spin_skill_points,
+      total_score: user.total_score,
+      username: user.username,
+      clans: user.clans as any,
+    })),
+  };
+}

package/api/getMapUploadUrl.ts

@@ -1,93 +1,93 @@
-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({
-    mapName: z.string().optional(),
-    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({
-  mapName,
-  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 > 50000000) {
-    return NextResponse.json({
-      error: "Max content length exceeded.",
-    });
-  }
-
-  if (contentType !== "application/octet-stream") {
-    return NextResponse.json({
-      error: "Unnacceptable format",
-    });
-  }
-
-  const key = `rhythia-${mapName ? mapName : user.id}-${Date.now()}.sspm`;
-  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({
+    mapName: z.string().optional(),
+    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({
+  mapName,
+  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 > 50000000) {
+    return NextResponse.json({
+      error: "Max content length exceeded.",
+    });
+  }
+
+  if (contentType !== "application/octet-stream") {
+    return NextResponse.json({
+      error: "Unnacceptable format",
+    });
+  }
+
+  const key = `rhythia-${mapName ? mapName : user.id}-${Date.now()}.sspm`;
+  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/getPassToken.ts

@@ -1,55 +1,55 @@
-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 { encryptString } from "../utils/security";
-export const Schema = {
-  input: z.strictObject({
-    data: z.object({
-      email: z.string(),
-      passkey: z.string(),
-      computerName: z.string(),
-    }),
-  }),
-  output: z.object({
-    token: z.string().optional(),
-    error: z.string().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"]>> {
-  let { data: queryPasskey, error } = await supabase
-    .from("passkeys")
-    .select("*")
-    .eq("email", data.data.email)
-    .eq("passkey", data.data.passkey)
-    .single();
-
-  if (!queryPasskey) {
-    return NextResponse.json({
-      error: "Wrong combination",
-    });
-  }
-  return NextResponse.json({
-    token: encryptString(
-      JSON.stringify({
-        userId: queryPasskey.id,
-        email: queryPasskey.email,
-        passKey: queryPasskey.passkey,
-        computerName: data.data.computerName,
-      })
-    ),
-  });
-}
+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 { encryptString } from "../utils/security";
+export const Schema = {
+  input: z.strictObject({
+    data: z.object({
+      email: z.string(),
+      passkey: z.string(),
+      computerName: z.string(),
+    }),
+  }),
+  output: z.object({
+    token: z.string().optional(),
+    error: z.string().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"]>> {
+  let { data: queryPasskey, error } = await supabase
+    .from("passkeys")
+    .select("*")
+    .eq("email", data.data.email)
+    .eq("passkey", data.data.passkey)
+    .single();
+
+  if (!queryPasskey) {
+    return NextResponse.json({
+      error: "Wrong combination",
+    });
+  }
+  return NextResponse.json({
+    token: encryptString(
+      JSON.stringify({
+        userId: queryPasskey.id,
+        email: queryPasskey.email,
+        passKey: queryPasskey.passkey,
+        computerName: data.data.computerName,
+      })
+    ),
+  });
+}