Member data validation (#70)

* added controller to get user details

* added endpoint for getting discord member details

* added new test

* changed user-id to discord-id

Author: DashDeipayan

src/controllers/getGuildMemberDetailsHandler.ts

@@ -0,0 +1,26 @@
+import * as response from "../constants/responses";
+import { env } from "../typeDefinitions/default.types";
+import JSONResponse from "../utils/JsonResponse";
+import { IRequest } from "itty-router";
+import { verifyAuthToken } from "../utils/verifyAuthToken";
+import { getGuildMemberDetails } from "../utils/getGuildMemberDetails";
+
+export async function getGuildMemberDetailsHandler(
+  request: IRequest,
+  env: env
+) {
+  const authHeader = request.headers.get("Authorization");
+  if (!authHeader) {
+    return new JSONResponse(response.BAD_SIGNATURE);
+  }
+  try {
+    await verifyAuthToken(authHeader, env);
+
+    const { id: discordId } = request.params;
+
+    const res = await getGuildMemberDetails(discordId, env);
+    return new JSONResponse(res);
+  } catch (err) {
+    return new JSONResponse(response.BAD_SIGNATURE);
+  }
+}

src/index.ts

@@ -12,6 +12,7 @@ import {
 } from "./controllers/guildRoleHandler";
 import { getMembersInServerHandler } from "./controllers/getMembersInServer";
 import { changeNickname } from "./controllers/changeNickname";
+import { getGuildMemberDetailsHandler } from "./controllers/getGuildMemberDetailsHandler";
 
 const router = Router();
 
@@ -29,6 +30,8 @@ router.put("/roles/add", addGroupRoleHandler);
 
 router.get("/discord-members", getMembersInServerHandler);
 
+router.get("/member/:id", getGuildMemberDetailsHandler);
+
 router.post("/", async (request, env) => {
   const message: discordMessageRequest = await request.json();
   if (message.type === InteractionType.PING) {

src/typeDefinitions/discordMessage.types.d.ts

@@ -53,3 +53,30 @@ export interface guildRoleResponse {
   mentionable: boolean;
   tags?: object;
 }
+
+export interface discordMemberDetails {
+  avatar: string;
+  communication_disabled_until: string;
+  flags: number;
+  joined_at: string;
+  nick: string;
+  pending: boolean;
+  premium_since: string;
+  roles: Array<string>;
+  user: {
+    id: string;
+    username: string;
+    avatar: string;
+    discriminator: string;
+    public_flags: number;
+    flags: number;
+    banner: string;
+    accent_color: string;
+    global_name: string;
+    avatar_decoration: string;
+    display_name: string;
+    banner_color: string;
+  };
+  mute: boolean;
+  deaf: boolean;
+}

src/utils/getGuildMemberDetails.ts

@@ -0,0 +1,27 @@
+import { INTERNAL_SERVER_ERROR } from "../constants/responses";
+import { DISCORD_BASE_URL } from "../constants/urls";
+import { env } from "../typeDefinitions/default.types";
+import { discordMemberDetails } from "../typeDefinitions/discordMessage.types";
+
+export async function getGuildMemberDetails(
+  discordId: string,
+  env: env
+): Promise<discordMemberDetails | string> {
+  const getGuildMemberDetailsUrl = `${DISCORD_BASE_URL}/guilds/${env.DISCORD_GUILD_ID}/members/${discordId}`;
+  try {
+    const response = await fetch(getGuildMemberDetailsUrl, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bot ${env.DISCORD_TOKEN}`,
+      },
+    });
+    if (response.ok) {
+      return await response.json();
+    } else {
+      return INTERNAL_SERVER_ERROR;
+    }
+  } catch (err) {
+    return INTERNAL_SERVER_ERROR;
+  }
+}

tests/fixtures/fixture.ts

@@ -51,3 +51,30 @@ export const guildEnv = {
   DISCORD_GUILD_ID: "1234",
   DISCORD_TOKEN: "abcd",
 };
+
+export const dummyGuildMemberDetails = {
+  avatar: null,
+  communication_disabled_until: null,
+  flags: 0,
+  joined_at: "2023-04-01T01:00:09.204000+00:00",
+  nick: null,
+  pending: false,
+  premium_since: null,
+  roles: [],
+  user: {
+    id: "12345678",
+    username: "John Doe",
+    avatar: "123abc123xyz",
+    discriminator: "6818",
+    public_flags: 64,
+    flags: 64,
+    banner: null,
+    accent_color: 16721920,
+    global_name: null,
+    avatar_decoration: null,
+    display_name: null,
+    banner_color: "#ff2800",
+  },
+  mute: false,
+  deaf: false,
+};

tests/unit/utils/getGuildMemberDetails.test.ts

@@ -0,0 +1,75 @@
+import { DISCORD_BASE_URL } from "../../../src/constants/urls";
+import { getGuildMemberDetails } from "../../../src/utils/getGuildMemberDetails";
+import { dummyGuildMemberDetails } from "../../fixtures/fixture";
+
+describe("getGuildMemberDetails", () => {
+  const mockEnv = {
+    BOT_PUBLIC_KEY: "xyz",
+    DISCORD_GUILD_ID: "123",
+    DISCORD_TOKEN: "abc",
+  };
+  const mockUserId = "12345678";
+  const GET_GUILD_MEMBER_URL = `${DISCORD_BASE_URL}/guilds/${mockEnv.DISCORD_GUILD_ID}/members/${mockUserId}`;
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  test("returns member details on success", async () => {
+    jest.spyOn(global, "fetch").mockResolvedValueOnce({
+      ok: true,
+      json: jest.fn().mockResolvedValueOnce(dummyGuildMemberDetails),
+    } as unknown as Response);
+
+    const result = await getGuildMemberDetails(mockUserId, mockEnv);
+
+    expect(global.fetch).toHaveBeenCalledWith(GET_GUILD_MEMBER_URL, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bot ${mockEnv.DISCORD_TOKEN}`,
+      },
+    });
+
+    expect(result).toEqual(dummyGuildMemberDetails);
+  });
+
+  test("returns INTERNAL_SERVER_ERROR on non-ok response", async () => {
+    jest.spyOn(global, "fetch").mockResolvedValueOnce({
+      ok: false,
+    } as unknown as Response);
+
+    const result = await getGuildMemberDetails(mockUserId, mockEnv);
+
+    expect(global.fetch).toHaveBeenCalledWith(GET_GUILD_MEMBER_URL, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bot ${mockEnv.DISCORD_TOKEN}`,
+      },
+    });
+
+    expect(result).toEqual(
+      "Oops! We have encountered an internal Server Error"
+    );
+  });
+
+  test("returns INTERNAL_SERVER_ERROR on fetch error", async () => {
+    jest
+      .spyOn(global, "fetch")
+      .mockRejectedValueOnce(new Error("Network error"));
+
+    const result = await getGuildMemberDetails(mockUserId, mockEnv);
+
+    expect(global.fetch).toHaveBeenCalledWith(GET_GUILD_MEMBER_URL, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bot ${mockEnv.DISCORD_TOKEN}`,
+      },
+    });
+
+    expect(result).toEqual(
+      "Oops! We have encountered an internal Server Error"
+    );
+  });
+});