improved the removeUsers functionality

Author: rishirishhh

src/controllers/baseHandler.ts

@@ -83,6 +83,7 @@ export async function baseHandler(
       const data = message.data?.options as Array<messageRequestDataOptions>;
       const transformedArgument = {
         roleToBeRemovedObj: data[0],
+        channelId: message.channel_id,
       };
       return await kickEachUser(transformedArgument, env, ctx);
     }

src/controllers/kickEachUser.ts

@@ -11,6 +11,7 @@ import { removeUsers } from "../utils/removeUsers";
 export async function kickEachUser(
   transformedArgument: {
     roleToBeRemovedObj: MentionEachUserOptions;
+    channelId: number;
   },
   env: env,
   ctx: ExecutionContext
@@ -34,8 +35,10 @@ export async function kickEachUser(
       `We couldn't find any user(s) assigned to <@&${roleId}> role.`
     );
   } else {
-    ctx.waitUntil(removeUsers(env, usersWithMatchingRole));
-    const responseText = `Following users are removed:\n${usersText}`;
+    ctx.waitUntil(
+      removeUsers(env, usersWithMatchingRole, transformedArgument.channelId)
+    );
+    const responseText = `Following users will be removed shortly ..... :\n${usersText}`;
     return discordTextResponse(responseText);
   }
 }

src/utils/removeUsers.ts

@@ -4,12 +4,21 @@ import {
   parseRateLimitRemaining,
   parseResetAfter,
 } from "./batchDiscordRequests";
+import {
+  discordMessageRequest,
+  discordMessageError,
+} from "../typeDefinitions/discordMessage.types";
 
-export async function removeUsers(env: env, usersWithMatchingRole: string[]) {
+export async function removeUsers(
+  env: env,
+  usersWithMatchingRole: string[],
+  channelId: number
+) {
   const batchSize = 4;
   let waitTillNextAPICall = 0;
 
   try {
+    const failedUsers: Array<string> = [];
     for (let i = 0; i < usersWithMatchingRole.length; i += batchSize) {
       const batchwiseUsers = usersWithMatchingRole.slice(i, i + batchSize);
       const deleteRequests = batchwiseUsers.map((mention) => {
@@ -22,32 +31,41 @@ export async function removeUsers(env: env, usersWithMatchingRole: string[]) {
             "Content-Type": "application/json",
             Authorization: `Bot ${env.DISCORD_TOKEN}`,
           },
-        }).then(async (response) => {
+        }).then((response) => {
           const rateLimitRemaining = parseRateLimitRemaining(response);
-
           if (rateLimitRemaining === 0) {
             waitTillNextAPICall = Math.max(
               parseResetAfter(response),
               waitTillNextAPICall
             );
           }
-
-          // Check if response status is 204 (No Content) indicating success
-          if (response.status === 204) {
-            return { success: true };
-          } else {
-            throw new Error(`Failed to remove user ${userId}.`);
-          }
-        });
+          return response.json();
+        }) as Promise<discordMessageRequest | discordMessageError>;
       });
 
-      // Wait for all delete requests in the batch to complete
-      await Promise.all(deleteRequests);
-
-      // Wait until the next API call is allowed based on rate limits
+      const responses = await Promise.all(deleteRequests);
+      responses.forEach((response, i) => {
+        if (response && "message" in response) {
+          failedUsers.push(batchwiseUsers[i]);
+          console.error(`Failed to remove a user`);
+        }
+      });
       await sleep(waitTillNextAPICall * 1000);
       waitTillNextAPICall = 0;
     }
+
+    if (failedUsers.length > 0) {
+      await fetch(`${DISCORD_BASE_URL}/channels/${channelId}/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bot ${env.DISCORD_TOKEN}`,
+        },
+        body: JSON.stringify({
+          content: `Failed to remove ${failedUsers}.`,
+        }),
+      });
+    }
   } catch (error) {
     console.error("Error occurred while removing users:", error);
   }

tests/unit/handlers/kickEachUser.test.ts

@@ -11,7 +11,7 @@ describe("kickEachUser", () => {
 
     const { roleToBeTaggedObj } = transformedArgument; // Extracting roleToBeTaggedObj
     const response = kickEachUser(
-      { roleToBeRemovedObj: roleToBeTaggedObj },
+      { roleToBeRemovedObj: roleToBeTaggedObj, channelId: 12345 },
       env,
       ctx
     );

tests/unit/utils/removeUsers.test.ts

@@ -9,6 +9,14 @@ describe("removeUsers", () => {
     DISCORD_TOKEN: "abc",
   };
 
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.resetAllMocks();
+  });
+
   test("removes users successfully", async () => {
     const usersWithMatchingRole = ["<@userId1>", "<@userId2>"];
 
@@ -17,7 +25,7 @@ describe("removeUsers", () => {
       .mockImplementation(() =>
         Promise.resolve(new Response(null, { status: 204 }))
       );
-    await removeUsers(mockEnv, usersWithMatchingRole);
+    await removeUsers(mockEnv, usersWithMatchingRole, 21121);
 
     expect(fetch).toHaveBeenCalledTimes(2);
     expect(fetch).toHaveBeenCalledWith(
@@ -52,7 +60,7 @@ describe("removeUsers", () => {
       );
 
     // Calling the function under test
-    await removeUsers(mockEnv, usersWithMatchingRole);
+    await removeUsers(mockEnv, usersWithMatchingRole, 23231);
 
     // Expectations
     expect(fetch).toHaveBeenCalledWith(
@@ -66,4 +74,21 @@ describe("removeUsers", () => {
       }
     );
   });
+
+  it("should send a message of failed api calls at the end", async () => {
+    let fetchCallCount = 0;
+    const usersWithMatchingRole = ["<@userId1>", "<@userId2>", "<@userId3>"];
+
+    jest.spyOn(global, "fetch").mockImplementation(async () => {
+      if (fetchCallCount < 3) {
+        fetchCallCount++;
+        return Promise.resolve(new JSONResponse({ message: "404: Not Found" }));
+      } else {
+        return Promise.resolve(new JSONResponse({ ok: true }));
+      }
+    });
+
+    await removeUsers(mockEnv, usersWithMatchingRole, 23231);
+    expect(fetch).toHaveBeenCalledTimes(4); // should send a message of failed api calls at the end
+  });
 });