change discord group fetching logic

src/constants/responses.ts

@@ -65,7 +65,8 @@ export const FAILED_TO_FETCH_TASKS = `Failed to fetch tasks for **{{assignee}}**
 export const USER_NOT_FOUND = `User Not Found`;
 export const USER_STATUS_NOT_FOUND = "No Status Found";
 
-export const FAILED_TO_FETCH_DISCORD_GROUPS = "Failed to fetch discord groups";
+export const FAILED_TO_FETCH_DISCORD_GUILD_ROLE =
+  "Failed to fetch discord guild role";
 
 export const OVERDUE_DEFAULT_MESSAGE = "You have overdue tasks.";
 export const OVERDUE_CUSTOM_MESSAGE =

src/controllers/groupInvite.ts

@@ -1,22 +1,21 @@
 import config from "../../config/config";
 import { env } from "../typeDefinitions/default.types";
 import { discordTextResponse } from "../utils/discordResponse";
-import * as DiscordGroups from "../utils/fetchDiscordGroups";
+import * as DiscordGroups from "../utils/fetchDiscordGroupById";
 import JSONResponse from "../utils/JsonResponse";
 
 export async function groupInvite(
   userId: string,
   roleId: string,
   env: env
 ): Promise<JSONResponse> {
-  const response = await DiscordGroups.fetchDiscordGroups(env);
-  const group = response.groups.find((group) => group.roleid === roleId);
+  const group = await DiscordGroups.fetchDiscordGroupById(roleId, env);
 
-  if (!group) {
+  if (!group.name.startsWith("group-")) {
     return discordTextResponse(`<@&${roleId}> is not a valid group.`);
   }
 
-  const groupName = group.rolename.replace(/^group-/, "");
+  const groupName = group.name.replace(/^group-/, "");
 
   return discordTextResponse(
     `<@${userId}> join the group <@&${roleId}> via the link below:\n ${

src/typeDefinitions/group.types.d.ts

@@ -1,18 +1,4 @@
-export type GroupType = {
+export type DiscordGuildRole = {
+  name: string;
   id: string;
-  date: {
-    _seconds: number;
-    _nanoseconds: number;
-  };
-  createdBy: string;
-  rolename: string;
-  roleid: string;
-  description: string;
-  memberCount: number;
-  isMember: boolean;
-};
-
-export type GroupResponseType = {
-  message: string;
-  groups: GroupType[];
 };

src/utils/fetchDiscordGroupById.ts

@@ -0,0 +1,34 @@
+import { FAILED_TO_FETCH_DISCORD_GUILD_ROLE } from "../constants/responses";
+import { DISCORD_BASE_URL } from "../constants/urls";
+import { env } from "../typeDefinitions/default.types";
+import { DiscordGuildRole } from "../typeDefinitions/group.types";
+import createDiscordHeaders from "./createDiscordHeaders";
+
+async function fetchDiscordGroupById(
+  roleId: string,
+  env: env
+): Promise<DiscordGuildRole> {
+  try {
+    const url = `${DISCORD_BASE_URL}/guilds/${env.DISCORD_GUILD_ID}/roles/${roleId}`;
+    const headers: HeadersInit = createDiscordHeaders({
+      token: env.DISCORD_TOKEN,
+    });
+    const options = {
+      method: "GET",
+      headers,
+    };
+    const response = await fetch(url, options);
+
+    if (!response.ok) {
+      throw new Error(FAILED_TO_FETCH_DISCORD_GUILD_ROLE);
+    }
+
+    const responseData: DiscordGuildRole = await response.json();
+    return responseData;
+  } catch (error) {
+    console.error("An error occurred while fetching discord groups:", error);
+    throw error;
+  }
+}
+
+export { fetchDiscordGroupById };

tests/fixtures/groups.ts

@@ -1,46 +1,11 @@
-import { GroupResponseType } from "../../src/typeDefinitions/group.types";
+import { DiscordGuildRole } from "../../src/typeDefinitions/group.types";
 
-export const groups: GroupResponseType = {
-  message: "Roles fetched successfully!",
-  groups: [
-    {
-      id: "27EdauP9UmxCTgAMDPpl",
-      date: {
-        _seconds: 1719334613,
-        _nanoseconds: 934000000,
-      },
-      createdBy: "zXQpimWaGWOFF2sLyrFt",
-      rolename: "group-testing 3",
-      roleid: "1255205109340573782",
-      description: "for testing",
-      memberCount: 0,
-      isMember: false,
-    },
-    {
-      id: "ELjCeNZxhHupn8qU5pWI",
-      date: {
-        _seconds: 1718771669,
-        _nanoseconds: 27000000,
-      },
-      createdBy: "zXQpimWaGWOFF2sLyrFt",
-      rolename: "group-testing",
-      roleid: "1252843931306164298",
-      description: "for testing",
-      memberCount: 0,
-      isMember: false,
-    },
-    {
-      id: "tO4vZe5CC690yOb9Txlh",
-      date: {
-        _seconds: 1718771969,
-        _nanoseconds: 680000000,
-      },
-      createdBy: "zXQpimWaGWOFF2sLyrFt",
-      rolename: "group-testinge",
-      roleid: "1252845191472087050",
-      description: "",
-      memberCount: 0,
-      isMember: false,
-    },
-  ],
+export const group: DiscordGuildRole = {
+  id: "1",
+  name: "group-frontend",
+};
+
+export const invalidGroup: DiscordGuildRole = {
+  id: "2",
+  name: "invalidRole",
 };

tests/unit/handlers/groupInvite.test.ts

@@ -1,39 +1,36 @@
 import { environment } from "../../fixtures/config";
-import * as DiscordGroups from "../../../src/utils/fetchDiscordGroups";
+import * as DiscordGroups from "../../../src/utils/fetchDiscordGroupById";
 import JSONResponse from "../../../src/utils/JsonResponse";
 import { groupInvite } from "../../../src/controllers/groupInvite";
-import { groups } from "../../fixtures/groups";
+import { group, invalidGroup } from "../../fixtures/groups";
 import { discordTextResponse } from "../../../src/utils/discordResponse";
 
 describe("Test /group-invite command", () => {
-  beforeEach(() => {
-    jest
-      .spyOn(DiscordGroups, "fetchDiscordGroups")
-      .mockImplementation(() => Promise.resolve(groups));
-  });
-
   afterEach(() => {
     jest.resetAllMocks();
     jest.restoreAllMocks();
   });
 
   it("Should be an instance of JSONResponse", async () => {
-    const response = await groupInvite(
-      "1",
-      groups.groups[0].roleid,
-      environment[0]
-    );
+    jest
+      .spyOn(DiscordGroups, "fetchDiscordGroupById")
+      .mockImplementation(() => Promise.resolve(group));
+
+    const response = await groupInvite("1", group.id, environment[0]);
 
     expect(response).toBeInstanceOf(JSONResponse);
   });
 
   it("Should return a discordTextResponse if group is not found", async () => {
-    const invalidRoleId = "invalidRoleId";
+    jest
+      .spyOn(DiscordGroups, "fetchDiscordGroupById")
+      .mockImplementation(() => Promise.resolve(invalidGroup));
+
     const expectedResponse = discordTextResponse(
-      `<@&${invalidRoleId}> is not a valid group.`
+      `<@&${invalidGroup.id}> is not a valid group.`
     );
 
-    const response = await groupInvite("1", invalidRoleId, environment[0]);
+    const response = await groupInvite("1", invalidGroup.id, environment[0]);
 
     expect(await response.json()).toEqual(await expectedResponse.json());
   });