rhythia-api 241.0.0 → 243.0.0

package/api/getFriends.ts

@@ -0,0 +1,154 @@
+import { NextResponse } from "../utils/response";
+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";
+
+const friendUserSchema = z.object({
+  id: z.number(),
+  username: z.string().nullable(),
+  avatar_url: z.string().nullable(),
+  flag: z.string().nullable(),
+  profile_image: z.string().nullable(),
+  is_online: z.boolean(),
+  last_active_timestamp: z.number().nullable(),
+  is_mutual: z.boolean(),
+});
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+  }),
+  output: z.strictObject({
+    error: z.string().optional(),
+    friends: z.array(friendUserSchema),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler({
+  session,
+}: (typeof Schema)["input"]["_type"]): Promise<
+  NextResponse<(typeof Schema)["output"]["_type"]>
+> {
+  const user = (await getUserBySession(session)) as User;
+
+  const { data: viewerProfile } = await supabase
+    .from("profiles")
+    .select("id")
+    .eq("uid", user.id)
+    .single();
+
+  if (!viewerProfile) {
+    return NextResponse.json({ error: "Can't find user", friends: [] });
+  }
+
+  const { data: outgoingRows, error: outgoingError } = await supabase
+    .from("profileFriends")
+    .select("friend_id,created_at")
+    .eq("profile_id", viewerProfile.id)
+    .order("created_at", { ascending: false });
+
+  if (outgoingError) {
+    return NextResponse.json({
+      error: outgoingError.message,
+      friends: [],
+    });
+  }
+
+  const outgoingIds = (outgoingRows || []).map((row) => row.friend_id);
+
+  if (!outgoingIds.length) {
+    return NextResponse.json({ friends: [] });
+  }
+
+  const [{ data: reverseRows, error: reverseError }, { data: profiles, error: profilesError }] =
+    await Promise.all([
+      supabase
+        .from("profileFriends")
+        .select("profile_id")
+        .in("profile_id", outgoingIds)
+        .eq("friend_id", viewerProfile.id),
+      supabase
+        .from("profiles")
+        .select("id,uid,username,avatar_url,flag,profile_image")
+        .in("id", outgoingIds)
+        .neq("ban", "excluded"),
+    ]);
+
+  if (reverseError) {
+    return NextResponse.json({
+      error: reverseError.message,
+      friends: [],
+    });
+  }
+
+  if (profilesError) {
+    return NextResponse.json({
+      error: profilesError.message,
+      friends: [],
+    });
+  }
+
+  const activityUids = (profiles || [])
+    .map((profile) => profile.uid)
+    .filter((uid): uid is string => !!uid);
+
+  const { data: activities, error: activitiesError } = activityUids.length
+    ? await supabase
+        .from("profileActivities")
+        .select("uid,last_activity")
+        .in("uid", activityUids)
+    : { data: [], error: null };
+
+  if (activitiesError) {
+    return NextResponse.json({
+      error: activitiesError.message,
+      friends: [],
+    });
+  }
+
+  const profileMap = new Map((profiles || []).map((profile) => [profile.id, profile]));
+  const mutualIds = new Set((reverseRows || []).map((row) => row.profile_id));
+  const activityMap = new Map(
+    (activities || []).map((activity) => [activity.uid, activity.last_activity])
+  );
+  const addedUsers = outgoingIds
+    .map((friendId) => profileMap.get(friendId))
+    .filter(
+      (
+        profile
+      ): profile is {
+        id: number;
+        uid: string | null;
+        username: string | null;
+        avatar_url: string | null;
+        flag: string | null;
+        profile_image: string | null;
+      } => !!profile
+    );
+
+  return NextResponse.json({
+    friends: addedUsers.map((profile) => ({
+      id: profile.id,
+      username: profile.username,
+      avatar_url: profile.avatar_url,
+      flag: profile.flag,
+      profile_image: profile.profile_image,
+      is_online:
+        typeof activityMap.get(profile.uid || "") === "number" &&
+        Date.now() - (activityMap.get(profile.uid || "") || 0) < 1800000,
+      last_active_timestamp: activityMap.get(profile.uid || "") ?? null,
+      is_mutual: mutualIds.has(profile.id),
+    })),
+  });
+}

package/api/getMapUploadUrl.ts

@@ -1,93 +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({
-    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 > 100000000) {
-    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 "../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 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 > 100000000) {
+    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,
+    ContentDisposition: "attachment",
+  });
+
+  const presigned = await getSignedUrl(s3Client, command, {
+    expiresIn: 3600,
+    signableHeaders: new Set(["content-type"]),
+  });
+  return NextResponse.json({
+    url: presigned,
+    objectKey: key,
+  });
+}