added route for generating discord invite link (RealDevSquad#130)

* added route for generating discord invite link

* testing initial code

* completed utils test

* controller function test

* tests for handler

* completed test for generateDiscordInvite handlers

* removed console logs

* removed unused fixture items

* remove unnecessary changes and types added in different file

* handling different error cases

* changed API method to post

* typo fix

---------

Co-authored-by: Sunny Sahsi <[email protected]>
Co-authored-by: Prakash Choudhary <[email protected]>

Author: 3 people

src/constants/inviteOptions.ts

@@ -0,0 +1,4 @@
+export const INVITE_OPTIONS = {
+  MAX_USE: 1,
+  UNIQUE: true,
+};

src/constants/responses.ts

@@ -14,6 +14,10 @@ export const STATUS_CHECK = {
   message: "Welcome to our discord Bot Server 👋",
 };
 
+export const TOO_MANY_REQUESTS = {
+  error: "Too many requests!",
+};
+
 export const COMMAND_NOT_FOUND = "Command Not Found";
 
 export const INTERNAL_SERVER_ERROR =
@@ -24,6 +28,8 @@ export const RETRY_COMMAND =
 
 export const ROLE_ADDED = "Role added successfully";
 
+export const INVITED_CREATED = "Invite created successfully!";
+
 export const NAME_CHANGED = "User nickname changed successfully";
 
 export const ROLE_REMOVED = "Role Removed successfully";
@@ -40,6 +46,9 @@ export const ROLE_FETCH_FAILED =
 export const BAD_REQUEST = {
   error: "Oops! This is not a proper request.",
 };
+export const UNAUTHORIZED = {
+  error: "UnAuthorized!",
+};
 
 export const LISTENING_SUCCESS_MESSAGE =
   "Your name is now changed to reflect your listening status";

src/controllers/generateDiscordInvite.ts

@@ -0,0 +1,22 @@
+import { IRequest } from "itty-router";
+import * as response from "../constants/responses";
+import { env } from "../typeDefinitions/default.types";
+import JSONResponse from "../utils/JsonResponse";
+import { verifyAuthToken } from "../utils/verifyAuthToken";
+import { generateDiscordLink } from "../utils/generateDiscordInvite";
+import { inviteLinkBody } from "../typeDefinitions/discordLink.types";
+
+export async function generateInviteLink(request: IRequest, env: env) {
+  const authHeader = request.headers.get("Authorization");
+  if (!authHeader) {
+    return new JSONResponse(response.BAD_SIGNATURE);
+  }
+  try {
+    await verifyAuthToken(authHeader, env);
+    const body: inviteLinkBody = await request.json();
+    const res = await generateDiscordLink(body, env);
+    return new JSONResponse(res);
+  } catch (err) {
+    return new JSONResponse(response.BAD_SIGNATURE);
+  }
+}

src/index.ts

@@ -17,6 +17,7 @@ import { getMembersInServerHandler } from "./controllers/getMembersInServer";
 import { changeNickname } from "./controllers/changeNickname";
 import { getGuildMemberDetailsHandler } from "./controllers/getGuildMemberDetailsHandler";
 import { send } from "./handlers/scheduledEventHandler";
+import { generateInviteLink } from "./controllers/generateDiscordInvite";
 
 const router = Router();
 
@@ -44,6 +45,7 @@ router.get("/member/:id", getGuildMemberDetailsHandler);
 router.patch("/guild/member", changeNickname);
 
 router.put("/roles/create", createGuildRoleHandler);
+router.post("/invite", generateInviteLink);
 
 router.put("/roles/add", addGroupRoleHandler);
 
@@ -71,10 +73,11 @@ router.all("*", async () => {
 
 export default {
   async fetch(request: Request, env: env): Promise<Response> {
-    if (request.method === "POST") {
+    const apiUrls = ["/invite"];
+    const url = new URL(request.url);
+    if (request.method === "POST" && !apiUrls.includes(url.pathname)) {
       const isVerifiedRequest = await verifyBot(request, env);
       if (!isVerifiedRequest) {
-        console.error("Invalid Request");
         return new JSONResponse(response.BAD_SIGNATURE, { status: 401 });
       }
     }

src/typeDefinitions/discordLink.types.d.ts

@@ -0,0 +1,8 @@
+export interface inviteLinkBody {
+  channelId: string;
+}
+
+export interface inviteResponseType {
+  message: string;
+  data: object;
+}

src/utils/generateDiscordInvite.ts

@@ -0,0 +1,57 @@
+import { INVITE_OPTIONS } from "../constants/inviteOptions";
+import {
+  BAD_REQUEST,
+  INTERNAL_SERVER_ERROR,
+  INVITED_CREATED,
+  NOT_FOUND,
+  TOO_MANY_REQUESTS,
+  UNAUTHORIZED,
+} from "../constants/responses";
+import { DISCORD_BASE_URL } from "../constants/urls";
+import { env } from "../typeDefinitions/default.types";
+import { inviteLinkBody } from "../typeDefinitions/discordLink.types";
+
+export async function generateDiscordLink(body: inviteLinkBody, env: env) {
+  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
+  };
+  try {
+    const response = await fetch(generateInviteUrl, {
+      method: "POST",
+      body: JSON.stringify(inviteOptions),
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bot ${env.DISCORD_TOKEN}`,
+      },
+    });
+
+    if (response.ok) {
+      const data = await response.json();
+      return { message: INVITED_CREATED, data };
+    } else {
+      if (response.status === 400) {
+        return BAD_REQUEST;
+      }
+
+      if (response.status === 401) {
+        return UNAUTHORIZED;
+      }
+
+      if (response.status === 404) {
+        return NOT_FOUND;
+      }
+
+      if (response.status === 429) {
+        return TOO_MANY_REQUESTS;
+      }
+
+      return INTERNAL_SERVER_ERROR;
+    }
+  } catch (err) {
+    return INTERNAL_SERVER_ERROR;
+  }
+}

tests/fixtures/fixture.ts

@@ -56,6 +56,10 @@ export const guildEnv = {
   DISCORD_TOKEN: "abcd",
 };
 
+export const dummyInviteBody = {
+  channelId: "1234",
+};
+
 export const dummyGuildMemberDetails = {
   avatar: null,
   communication_disabled_until: null,
@@ -106,13 +110,15 @@ export const generateDummyRequestObject = ({
   params,
   query,
   headers, // Object of key value pair
+  json,
 }: Partial<IRequest>): IRequest => {
   return {
     method: method ?? "GET",
     url: url ?? "/roles",
     params: params ?? {},
     query: query ?? {},
     headers: new Map(Object.entries(headers ?? {})),
+    json: json,
   };
 };
 

tests/unit/handlers/generateDiscordInvite.test.ts

@@ -0,0 +1,55 @@
+import { generateInviteLink } from "../../../src/controllers/generateDiscordInvite";
+import JSONResponse from "../../../src/utils/JsonResponse";
+import { generateDummyRequestObject, guildEnv } from "../../fixtures/fixture";
+import * as responseConstants from "../../../src/constants/responses";
+import { inviteResponseType } from "../../../src/typeDefinitions/discordLink.types";
+
+jest.mock("../../../src/utils/verifyAuthToken", () => ({
+  verifyAuthToken: jest.fn().mockReturnValue(true),
+}));
+
+jest.mock("../../../src/utils/generateDiscordInvite", () => ({
+  generateDiscordLink: jest
+    .fn()
+    .mockReturnValue({ data: {}, message: "Invite created successfully!" }),
+}));
+
+describe("generate discord link", () => {
+  it("should return 🚫 Bad Request Signature' if authtoken is there in the header", async () => {
+    const mockRequest = generateDummyRequestObject({
+      url: "/invite",
+    });
+
+    const response: JSONResponse = await generateInviteLink(
+      mockRequest,
+      guildEnv
+    );
+
+    const jsonResponse: { error: string } = await response.json();
+    expect(jsonResponse).toEqual(responseConstants.BAD_SIGNATURE);
+  });
+
+  it("should return data object with message on success", async () => {
+    const mockRequest = generateDummyRequestObject({
+      method: "PUT",
+      url: "/invite",
+      headers: {
+        Authorization: "Bearer testtoken",
+        "Content-Type": "application/json",
+      },
+      json: async () => {
+        return { channelId: "xyz" };
+      },
+    });
+
+    const response: JSONResponse = await generateInviteLink(
+      mockRequest,
+      guildEnv
+    );
+
+    const jsonResponse: inviteResponseType = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(jsonResponse.message).toEqual(responseConstants.INVITED_CREATED);
+  });
+});

tests/unit/utils/generateDiscordInvite.test.ts

@@ -0,0 +1,57 @@
+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";
+
+describe("generate invite link", () => {
+  test("should return INTERNAL_SERVER_ERROR when response is not ok", async () => {
+    const mockResponse = new Response(null, { status: 500 });
+    jest
+      .spyOn(global, "fetch")
+      .mockImplementation(() => Promise.resolve(mockResponse));
+
+    const result = await generateDiscordLink(dummyInviteBody, guildEnv);
+    expect(result).toEqual(response.INTERNAL_SERVER_ERROR);
+    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,
+        }),
+      }
+    );
+  });
+
+  test("should return JSON response when response is ok", async () => {
+    const mockResponse = {};
+    jest
+      .spyOn(global, "fetch")
+      .mockImplementation(() =>
+        Promise.resolve(new JSONResponse(mockResponse))
+      );
+
+    const result = await generateDiscordLink(dummyInviteBody, guildEnv);
+    expect(result).toEqual({ data: {}, message: response.INVITED_CREATED });
+    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,
+        }),
+      }
+    );
+  });
+});