feat: rework on existing mention-each command (#76)

* feat: changing format of command

* refactor: formattingd

* feat: changed input argument

* feat: rework on existing code based on input

* fix:output for changing the input

* refactor: rework on test :(

* refactor:test constants to fixtures

* chore: linting

* feat:added comments

* chore: linting

Author: vvaibhavdesai

src/constants/commands.ts

@@ -10,61 +10,20 @@ export const VERIFY = {
 };
 
 export const MENTION_EACH = {
-  name: "mention",
+  name: "mention-each",
   description: "mention each user with this role",
   options: [
     {
-      name: "list",
-      description: "get user in list",
-      type: 2, // 2 is type SUB_COMMAND_GROUP
-      options: [
-        {
-          name: "get",
-          description: "get me the role ",
-          type: 1, // 1 is type SUB_COMMAND
-          options: [
-            {
-              name: "user",
-              description: "The user to get",
-              type: 9, // 6 is type USER
-              required: true,
-            },
-            {
-              name: "message",
-              description: "What message to send to user ?",
-              type: 3, // 7 is type CHANNEL
-              required: true,
-            },
-          ],
-        },
-      ],
+      name: "role",
+      description: "to be tagged in the message",
+      type: 8, // 2 is type SUB_COMMAND_GROUP
+      required: true,
     },
     {
-      name: "series",
-      description: "get user in series",
-      type: 2,
-      options: [
-        {
-          name: "get",
-          description: "get me the role",
-          type: 1,
-          options: [
-            {
-              name: "user",
-              description: "The user to get",
-              type: 9, // 8 is type ROLE
-              required: true,
-            },
-            {
-              name: "message",
-              description:
-                "The channel permissions to get. If omitted, the guild permissions will be returned",
-              type: 3,
-              required: true,
-            },
-          ],
-        },
-      ],
+      name: "message",
+      description: "any message for them?",
+      type: 3,
+      require: false,
     },
   ],
 };

src/controllers/baseHandler.ts

@@ -36,14 +36,14 @@ export async function baseHandler(
     }
     case getCommandName(MENTION_EACH): {
       const data = message.data?.options as Array<messageRequestDataOptions>;
+      // data[0] is role obj
+      // data[1] is message obj
+      const transformedArgument = {
+        roleToBeTaggedObj: data[0],
+        displayMessageObj: data[1] ?? {},
+      };
 
-      return await mentionEachUser(
-        {
-          displayType: data[0].name,
-          options: data[0].options[0].options,
-        },
-        env
-      );
+      return await mentionEachUser(transformedArgument, env);
     }
     default: {
       return commandNotFound();

src/controllers/mentionEachUser.ts

@@ -10,27 +10,25 @@ import {
 import { checkDisplayType } from "../utils/checkDisplayType";
 
 export async function mentionEachUser(
-  message: { displayType: string; options: Array<MentionEachUserOptions> },
+  transformedArgument: {
+    roleToBeTaggedObj: MentionEachUserOptions;
+    displayMessageObj?: MentionEachUserOptions;
+  },
   env: env
 ) {
   const getMembersInServerResponse = await getMembersInServer(env);
-
-  // displaytype is list or series  & options is first level of options array on desctructure
-  const { displayType, options } = message;
-  const [roleToBeTaggedObj, displayMessageObj] = options;
-
-  const roleId = roleToBeTaggedObj.value;
-  const msgToBeSent = displayMessageObj.value;
+  const roleId = transformedArgument.roleToBeTaggedObj.value;
+  // optional chaining here only because display message obj is optional argument
+  const msgToBeSent = transformedArgument?.displayMessageObj?.value;
 
   const usersWithMatchingRole = filterUserByRoles(
     getMembersInServerResponse as UserArray[],
     roleId
   );
 
   const responseData = checkDisplayType({
-    displayType,
-    msgToBeSent,
     usersWithMatchingRole,
+    msgToBeSent,
   });
   return discordTextResponse(responseData);
 }

src/utils/checkDisplayType.ts

@@ -1,19 +1,18 @@
+// const excludeThis = [undefined, null]
+// put a check for the above things later
+
 export function checkDisplayType({
-  displayType,
   msgToBeSent,
   usersWithMatchingRole,
 }: {
-  displayType: string;
-  msgToBeSent: string;
+  msgToBeSent?: string;
   usersWithMatchingRole: string[];
 }) {
-  if (displayType === "list") {
-    return `Coming soon. We are working on this feature. We feel sorry for not serving you what you expect this command to do for now.(T_T)`;
+  if (usersWithMatchingRole.length > 0) {
+    const returnString = msgToBeSent ? msgToBeSent : "";
+
+    return `${returnString} ${usersWithMatchingRole} \n \`Disclaimer: Very soon all the users will be tagged individually in a separate(new) message!\``;
   } else {
-    if (usersWithMatchingRole.length > 0) {
-      return `${displayType && msgToBeSent} ${usersWithMatchingRole}`;
-    } else {
-      return `Sorry no user found under this role.`;
-    }
+    return `Sorry no user found under this role.`;
   }
 }

tests/fixtures/fixture.ts

@@ -78,3 +78,20 @@ export const dummyGuildMemberDetails = {
   mute: false,
   deaf: false,
 };
+
+export const transformedArgument = {
+  roleToBeTaggedObj: {
+    name: "role",
+    type: 8,
+    value: "1118201414078976192",
+  },
+  displayMessageObj: { name: "message", type: 3, value: "hello" },
+};
+
+export const onlyRoleToBeTagged = {
+  roleToBeTaggedObj: {
+    name: "role",
+    type: 8,
+    value: "1118201414078976192",
+  },
+};

tests/unit/handlers/mentionEachUser.test.ts

@@ -1,6 +1,10 @@
 import { mentionEachUser } from "../../../src/controllers/mentionEachUser";
 import { filterUserByRoles } from "../../../src/utils/filterUsersByRole";
 import { checkDisplayType } from "../../../src/utils/checkDisplayType";
+import {
+  onlyRoleToBeTagged,
+  transformedArgument,
+} from "../../fixtures/fixture";
 
 describe("Test mention each function", () => {
   it("Should be an instance of JSONResponse", () => {
@@ -9,27 +13,23 @@ describe("Test mention each function", () => {
       DISCORD_GUILD_ID: "123",
       DISCORD_TOKEN: "abc",
     };
-    const optionsArray = [
-      {
-        name: "user",
-        type: 9,
-        value: "860900892193456149",
-      },
-      {
-        name: "message",
-        type: 3,
-        value: "hello",
-      },
-    ];
 
-    const response = mentionEachUser(
-      { displayType: "series", options: optionsArray },
-      env
-    );
+    const response = mentionEachUser(transformedArgument, env);
     expect(response).toBeInstanceOf(Promise);
   });
 
-  it("should filter users based on role", () => {
+  it("should run without displayMessageObj argument", () => {
+    const env = {
+      BOT_PUBLIC_KEY: "xyz",
+      DISCORD_GUILD_ID: "123",
+      DISCORD_TOKEN: "abc",
+    };
+
+    const response = mentionEachUser(onlyRoleToBeTagged, env);
+    expect(response).toBeInstanceOf(Promise);
+  });
+
+  it("should return users with matching roles", () => {
     const roleId = "860900892193456149";
     const optionsArray = [
       {
@@ -56,47 +56,40 @@ describe("Test mention each function", () => {
       },
     ];
     const response = filterUserByRoles(optionsArray, roleId);
-    const expectedResponse = ["<@282859044593598464>", "<@725745030706364447>"];
-    expect(response).toStrictEqual(expectedResponse);
+    expect(response).toStrictEqual([
+      "<@282859044593598464>",
+      "<@725745030706364447>",
+    ]);
   });
 
-  it("should return a message if users are not found (usersWithMatchingRole array is empty)", () => {
+  it("should return message based on the input", () => {
+    const usersWithMatchingRole = [
+      "<@282859044593598464>",
+      "<@725745030706364447>",
+    ];
     const msgToBeSent = "hello";
-
-    const response = checkDisplayType({
-      displayType: "series",
-      msgToBeSent,
-      usersWithMatchingRole: [],
-    });
-    const expectedResponse = `Sorry no user found under this role.`;
-
+    const response = checkDisplayType({ usersWithMatchingRole, msgToBeSent });
+    const expectedResponse = `${msgToBeSent} ${usersWithMatchingRole} \n \`Disclaimer: Very soon all the users will be tagged individually in a separate(new) message!\``;
     expect(response).toBe(expectedResponse);
   });
 
-  it("should return message if displayType is list", () => {
+  it("should return default string ", () => {
+    const usersWithMatchingRole = [] as string[];
     const msgToBeSent = "hello";
-
-    const response = checkDisplayType({
-      displayType: "list",
-      msgToBeSent,
-      usersWithMatchingRole: [],
-    });
-    const expectedResponse = `Coming soon. We are working on this feature. We feel sorry for not serving you what you expect this command to do for now.(T_T)`;
-
+    const response = checkDisplayType({ usersWithMatchingRole, msgToBeSent });
+    const expectedResponse = `Sorry no user found under this role.`;
     expect(response).toBe(expectedResponse);
   });
 
-  it("should return a message if users are found (usersWithMatchingRole array is not empty)", () => {
-    const msgToBeSent = "hello";
-
-    const response = checkDisplayType({
-      displayType: "series",
-      msgToBeSent,
-      usersWithMatchingRole: ["<@282859044593598464>", "<@725745030706364447>"],
-    });
-    const expectedResponse =
-      "hello <@282859044593598464>,<@725745030706364447>";
-
+  it("should return default string ", () => {
+    const usersWithMatchingRole = [
+      "<@282859044593598464>",
+      "<@725745030706364447>",
+    ] as string[];
+    const msgToBeSent = undefined;
+    const response = checkDisplayType({ usersWithMatchingRole, msgToBeSent });
+    const returnString = msgToBeSent ? msgToBeSent : "";
+    const expectedResponse = `${returnString} ${usersWithMatchingRole} \n \`Disclaimer: Very soon all the users will be tagged individually in a separate(new) message!\``;
     expect(response).toBe(expectedResponse);
   });
 });