feat: add Discord role management functionality (#315)

* feat: add Discord role management for invite generation

* feat: restructure Discord role management for environment-specific configurations

Author: AnujChhikara

config/config.ts

@@ -23,6 +23,7 @@ import {
   DISCORD_PROFILE_SERVICE_DEVELOPMENT_HELP_GROUP,
 } from "../src/constants/variables";
 import { config as configFromDotEnv } from "dotenv";
+import { DISCORD_ROLE_IDS } from "../src/constants/discordRoles";
 
 export function loadEnv(env: env, fromWorkerEnv: boolean): env {
   const Env: env = {
@@ -78,6 +79,7 @@ const config = (env: env) => {
       RDS_STATUS_SITE_URL: RDS_STATUS_SITE_URL,
       DASHBOARD_SITE_URL: RDS_DASHBOARD_SITE_URL,
       MAIN_SITE_URL: RDS_MAIN_SITE_URL,
+      DISCORD_ROLE_IDS: DISCORD_ROLE_IDS.PRODUCTION,
     },
     staging: {
       RDS_BASE_API_URL: RDS_BASE_STAGING_API_URL,
@@ -87,6 +89,7 @@ const config = (env: env) => {
       RDS_STATUS_SITE_URL: RDS_STAGING_STATUS_SITE_URL,
       DASHBOARD_SITE_URL: RDS_STAGING_DASHBOARD_SITE_URL,
       MAIN_SITE_URL: RDS_STAGING_MAIN_SITE_URL,
+      DISCORD_ROLE_IDS: DISCORD_ROLE_IDS.STAGING,
     },
     default: {
       RDS_BASE_API_URL: RDS_BASE_DEVELOPMENT_API_URL,
@@ -97,6 +100,7 @@ const config = (env: env) => {
       RDS_STATUS_SITE_URL: RDS_STATUS_SITE_URL,
       DASHBOARD_SITE_URL: RDS_DASHBOARD_SITE_URL,
       MAIN_SITE_URL: RDS_DEVELOPMENT_MAIN_SITE_URL,
+      DISCORD_ROLE_IDS: DISCORD_ROLE_IDS.DEVELOPMENT,
     },
   };
 

src/constants/discordRoles.ts

@@ -0,0 +1,32 @@
+export const DISCORD_ROLE_IDS = {
+  STAGING: {
+    DEVELOPER: "1121445071213056071",
+    DESIGNER: "1471575340714430678",
+    PRODUCT_MANAGER: "1471575685951656089",
+    PROJECT_MANAGER: "1471575735385850018",
+    QA: "1471575044806148331",
+    SOCIAL_MEDIA: "1471575596554522848",
+    UNVERIFIED: "1120875993771544687",
+    NEW: "963882131581464697",
+  },
+  PRODUCTION: {
+    DEVELOPER: "915490782939582485",
+    DESIGNER: "1472512698628571188",
+    PRODUCT_MANAGER: "1472512895295160475",
+    PROJECT_MANAGER: "1472512930582106244",
+    QA: "1472512746464743485",
+    SOCIAL_MEDIA: "1472512852542750874",
+    UNVERIFIED: "1103047289330745386",
+    NEW: "1013636976647348395",
+  },
+  DEVELOPMENT: {
+    DEVELOPER: "1463240239446233240",
+    DESIGNER: "1463240507651129497",
+    PRODUCT_MANAGER: "1468834132506448004",
+    PROJECT_MANAGER: "1468834221929005241",
+    QA: "1468833384813035560",
+    SOCIAL_MEDIA: "1468833506976075999",
+    UNVERIFIED: "1463240337458987319",
+    NEW: "1463240348997386271",
+  },
+} as const;

src/typeDefinitions/default.types.d.ts

@@ -14,6 +14,7 @@ export interface variables {
   PROFILE_SERVICE_HELP_GROUP_ID: string;
   RDS_STATUS_SITE_URL: string;
   MAIN_SITE_URL: string;
+  DISCORD_ROLE_IDS: typeof DISCORD_ROLE_IDS;
 }
 
 export interface discordCommand {

src/typeDefinitions/discordLink.types.d.ts

@@ -1,5 +1,6 @@
 export interface inviteLinkBody {
   channelId: string;
+  role: string;
 }
 
 export interface inviteResponseType {

src/utils/generateDiscordInvite.ts

@@ -1,3 +1,4 @@
+import config from "../../config/config";
 import { INVITE_OPTIONS } from "../constants/inviteOptions";
 import {
   BAD_REQUEST,
@@ -11,18 +12,29 @@ import { DISCORD_BASE_URL } from "../constants/urls";
 import { env } from "../typeDefinitions/default.types";
 import { inviteLinkBody } from "../typeDefinitions/discordLink.types";
 import createDiscordHeaders from "./createDiscordHeaders";
+import { getInviteRoleId } from "./getInviteRoleIds";
 
 export async function generateDiscordLink(
   body: inviteLinkBody,
   env: env,
   reason?: string
 ) {
+  let roleIds: string[];
+  try {
+    const roleIdsConfig = config(env).DISCORD_ROLE_IDS;
+    const applicationRoleId = getInviteRoleId(body.role, env);
+    roleIds = [applicationRoleId, roleIdsConfig.UNVERIFIED, roleIdsConfig.NEW];
+  } catch {
+    return BAD_REQUEST;
+  }
+
   const { channelId } = body;
   const generateInviteUrl = `${DISCORD_BASE_URL}/channels/${channelId}/invites`;
 
   const inviteOptions = {
     max_uses: INVITE_OPTIONS.MAX_USE, // Maximum number of times the invite can be used
     unique: INVITE_OPTIONS.UNIQUE, // Whether to create a unique invite or not
+    role_ids: roleIds,
   };
   try {
     const headers: HeadersInit = createDiscordHeaders({

src/utils/getInviteRoleIds.ts

@@ -0,0 +1,12 @@
+import config from "../../config/config";
+import type { env } from "../typeDefinitions/default.types";
+
+export function getInviteRoleId(role: string, env: env): string {
+  const normalizedRole = role?.trim().toUpperCase();
+  if (!normalizedRole) throw new Error("Role is required");
+
+  const roleIds = config(env).DISCORD_ROLE_IDS[normalizedRole];
+  if (!roleIds) throw new Error(`Invalid role: ${role}`);
+
+  return roleIds;
+}

tests/fixtures/fixture.ts

@@ -64,6 +64,7 @@ export const guildEnv = {
 
 export const dummyInviteBody = {
   channelId: "1234",
+  role: "developer",
 };
 
 export const dummyGuildMemberDetails = {

tests/unit/utils/generateDiscordInvite.test.ts

@@ -1,9 +1,16 @@
+import { DISCORD_ROLE_IDS } from "../../../src/constants/discordRoles";
 import { INVITE_OPTIONS } from "../../../src/constants/inviteOptions";
 import * as response from "../../../src/constants/responses";
 import JSONResponse from "../../../src/utils/JsonResponse";
 import { generateDiscordLink } from "../../../src/utils/generateDiscordInvite";
 import { dummyInviteBody, guildEnv } from "../../fixtures/fixture";
 
+const defaultRoleIds = [
+  DISCORD_ROLE_IDS.DEVELOPMENT.DEVELOPER,
+  DISCORD_ROLE_IDS.DEVELOPMENT.UNVERIFIED,
+  DISCORD_ROLE_IDS.DEVELOPMENT.NEW,
+];
+
 describe("generate invite link", () => {
   it("should pass the reason to discord as a X-Audit-Log-Reason header if provided", async () => {
     jest
@@ -26,6 +33,7 @@ describe("generate invite link", () => {
         body: JSON.stringify({
           max_uses: INVITE_OPTIONS.MAX_USE,
           unique: INVITE_OPTIONS.UNIQUE,
+          role_ids: defaultRoleIds,
         }),
       }
     );
@@ -49,6 +57,7 @@ describe("generate invite link", () => {
         body: JSON.stringify({
           max_uses: INVITE_OPTIONS.MAX_USE,
           unique: INVITE_OPTIONS.UNIQUE,
+          role_ids: defaultRoleIds,
         }),
       }
     );
@@ -75,8 +84,56 @@ describe("generate invite link", () => {
         body: JSON.stringify({
           max_uses: INVITE_OPTIONS.MAX_USE,
           unique: INVITE_OPTIONS.UNIQUE,
+          role_ids: defaultRoleIds,
         }),
       }
     );
   });
+
+  test("should include three role_ids when role is passed (staging)", async () => {
+    jest
+      .spyOn(global, "fetch")
+      .mockImplementation(() => Promise.resolve(new JSONResponse({})));
+
+    await generateDiscordLink(
+      { ...dummyInviteBody, role: "developer" },
+      guildEnv
+    );
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      `https://discord.com/api/v10/channels/${dummyInviteBody.channelId}/invites`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bot ${guildEnv.DISCORD_TOKEN}`,
+        },
+        body: JSON.stringify({
+          max_uses: INVITE_OPTIONS.MAX_USE,
+          unique: INVITE_OPTIONS.UNIQUE,
+          role_ids: [
+            DISCORD_ROLE_IDS.DEVELOPMENT.DEVELOPER,
+            DISCORD_ROLE_IDS.DEVELOPMENT.UNVERIFIED,
+            DISCORD_ROLE_IDS.DEVELOPMENT.NEW,
+          ],
+        }),
+      }
+    );
+  });
+
+  test("should return BAD_REQUEST when role is invalid or unknown", async () => {
+    const result = await generateDiscordLink(
+      { ...dummyInviteBody, role: "unknown_role" },
+      guildEnv
+    );
+    expect(result).toEqual(response.BAD_REQUEST);
+  });
+
+  test("should return BAD_REQUEST when role is empty", async () => {
+    const result = await generateDiscordLink(
+      { ...dummyInviteBody, role: "" },
+      guildEnv
+    );
+    expect(result).toEqual(response.BAD_REQUEST);
+  });
 });

tests/unit/utils/getInviteRoleIds.test.ts

@@ -0,0 +1,78 @@
+import { DISCORD_ROLE_IDS } from "../../../src/constants/discordRoles";
+import { getInviteRoleId } from "../../../src/utils/getInviteRoleIds";
+
+const APPLICATION_ROLE_KEYS: Record<
+  string,
+  keyof typeof DISCORD_ROLE_IDS.STAGING
+> = {
+  developer: "DEVELOPER",
+  designer: "DESIGNER",
+  product_manager: "PRODUCT_MANAGER",
+  project_manager: "PROJECT_MANAGER",
+  qa: "QA",
+  social_media: "SOCIAL_MEDIA",
+};
+
+const stagingEnv = { CURRENT_ENVIRONMENT: "staging" };
+const productionEnv = { CURRENT_ENVIRONMENT: "production" };
+const defaultEnv = { CURRENT_ENVIRONMENT: "default" };
+
+describe("getInviteRoleIds", () => {
+  describe("when role is missing or invalid", () => {
+    it("throws when role is undefined", () => {
+      expect(() =>
+        getInviteRoleId(undefined as unknown as string, stagingEnv)
+      ).toThrow("Role is required");
+    });
+
+    it("throws when role is empty string", () => {
+      expect(() => getInviteRoleId("", stagingEnv)).toThrow("Role is required");
+    });
+
+    it("throws when role is whitespace only", () => {
+      expect(() => getInviteRoleId("   ", stagingEnv)).toThrow(
+        "Role is required"
+      );
+    });
+
+    it("throws when role is unknown", () => {
+      expect(() => getInviteRoleId("unknown_role", stagingEnv)).toThrow(
+        "Invalid role: unknown_role"
+      );
+    });
+  });
+
+  describe("when role is valid", () => {
+    it("returns staging role ID for valid role in staging env", () => {
+      const result = getInviteRoleId("developer", stagingEnv);
+      expect(result).toBe(DISCORD_ROLE_IDS.STAGING.DEVELOPER);
+    });
+
+    it("returns production role ID for valid role in production env", () => {
+      const result = getInviteRoleId("developer", productionEnv);
+      expect(result).toBe(DISCORD_ROLE_IDS.PRODUCTION.DEVELOPER);
+    });
+
+    it("returns development role ID when CURRENT_ENVIRONMENT is default", () => {
+      const result = getInviteRoleId("designer", defaultEnv);
+      expect(result).toBe(DISCORD_ROLE_IDS.DEVELOPMENT.DESIGNER);
+    });
+
+    it("normalizes role to lowercase (case-insensitive)", () => {
+      const result = getInviteRoleId("Developer", stagingEnv);
+      expect(result).toBe(DISCORD_ROLE_IDS.STAGING.DEVELOPER);
+    });
+
+    it("trims whitespace from role", () => {
+      const result = getInviteRoleId("  developer  ", stagingEnv);
+      expect(result).toBe(DISCORD_ROLE_IDS.STAGING.DEVELOPER);
+    });
+
+    it("returns correct ID for each of the 6 application roles (staging)", () => {
+      for (const [role, key] of Object.entries(APPLICATION_ROLE_KEYS)) {
+        const result = getInviteRoleId(role, stagingEnv);
+        expect(result).toBe(DISCORD_ROLE_IDS.STAGING[key]);
+      }
+    });
+  });
+});