fix: replaced direct imports of githubDiscordMap.json with UserService

Author: isharghura

src/infrastructure/discord/authz.ts

@@ -1,22 +1,9 @@
-import githubDiscordMapJson from "../../../data/githubDiscordMap.json";
+import { UserService } from "@src/items/services/UserService";
 
-// New structure: map from GitHub username to object with discordId
-const githubDiscordMap: {
-  [key: string]: {
-    githubUsername: string;
-    githubId: string;
-    discordId: string;
-  };
-} = githubDiscordMapJson;
-
-// TODO: this any should be the generalized discord.js interaction type so that all interactions can leverage this method
-export const can = (interaction: any): boolean => {
+export const can = async (interaction: any): Promise<boolean> => {
   const userId = interaction.user?.id;
+  if (!userId) return false;
 
-  const discordIds = Object.values(githubDiscordMap).map(
-    (entry) => entry.discordId,
-  );
-  const isAuthorized = discordIds.includes(userId);
-
-  return isAuthorized;
+  const userResult = await UserService.findUserByDiscordID(userId);
+  return userResult.ok;
 };

src/infrastructure/discord/commands/myIssues.ts

@@ -1,20 +1,11 @@
 import { SlashCommandBuilder, CommandInteraction } from "discord.js";
 import { GithubAPI } from "@infrastructure/github";
 import logger from "@config/logger";
-import githubDiscordMapJson from "../../../../data/githubDiscordMap.json";
+import { UserService } from "@src/items/services/UserService";
 import { can } from "../authz";
 import { buildIssueButtonRow } from "../builders";
 import { formatDiscordDate } from "../webhookMessages";
 
-// Update type to reflect new structure
-const githubDiscordMap: {
-  [githubUsername: string]: {
-    githubUsername: string;
-    githubId: string;
-    discordId: string;
-  };
-} = githubDiscordMapJson;
-
 export const data = new SlashCommandBuilder()
   .setName("my-issues")
   .setDescription("List all GitHub project issues assigned to you")
@@ -35,19 +26,19 @@ export async function execute(interaction: CommandInteraction) {
   }
 
   const discordUserId = interaction.user.id;
-
-  const githubUsername = Object.values(githubDiscordMap).find(
-    (entry) => entry.discordId === discordUserId,
-  )?.githubUsername;
-
-  if (!githubUsername) {
+  
+  const userResult = await UserService.findUserByDiscordID(discordUserId);
+  if (userResult.err) {
     await interaction.reply({
       content: "❌ You don’t appear to be linked to a GitHub account.",
       ephemeral: true,
     });
     return;
   }
 
+  const githubUsername = userResult.val.githubUsername;
+
+
   await interaction.deferReply({ ephemeral: true });
 
   const githubItemsResult = await GithubAPI.fetchProjectItems();

src/infrastructure/discord/interactions/assigneeSelectInteraction.ts

@@ -1,15 +1,6 @@
 import { ItemService } from "@src/items/services";
 import { UserSelectMenuInteraction } from "discord.js";
-import githubDiscordMapJson from "../../../../data/githubDiscordMap.json";
-
-// Updated structure of the map
-const githubDiscordMap: {
-  [githubUsername: string]: {
-    githubUsername: string;
-    githubId: string;
-    discordId: string;
-  };
-} = githubDiscordMapJson;
+import { UserService } from "@src/items/services/UserService";
 
 export async function assigneeSelectInteraction(
   interaction: UserSelectMenuInteraction,
@@ -22,19 +13,18 @@ export async function assigneeSelectInteraction(
   const githubIssueId = match[1];
   const selectedUserId = interaction.values[0];
 
-  // Find the GitHub ID using the selected Discord ID
-  const githubId = Object.values(githubDiscordMap).find(
-    (entry) => entry.discordId === selectedUserId,
-  )?.githubId;
-
-  if (!githubId) {
+  const userResult = await UserService.findUserByDiscordID(selectedUserId);
+  if (userResult.err) {
     await interaction.reply({
-      content: "❌ Unable to find linked GitHub account for selected user.",
+      content: "❌ You don’t appear to be linked to a GitHub account.",
       ephemeral: true,
     });
     return;
   }
 
+  // Find the GitHub ID using the selected Discord ID
+  const githubId = userResult.val.githubId
+
   const result = await ItemService.updateAssignee({
     itemId: githubIssueId,
     assigneeId: githubId,

src/infrastructure/discord/tasks/urgentItemsDirectMessage.ts

@@ -2,16 +2,7 @@ import { GithubAPI } from "@infrastructure/github";
 import logger from "@src/config/logger";
 import { filterOutStatus, filterForUrgentItems } from "@src/items";
 import { formatDiscordDate } from "../webhookMessages";
-
-type GithubDiscordMapping = {
-  [githubUsername: string]: {
-    githubUsername: string;
-    githubId: string;
-    discordId: string;
-  };
-};
-import githubDiscordMapJson from "../../../../data/githubDiscordMap.json";
-const githubDiscordMap = githubDiscordMapJson as GithubDiscordMapping;
+import { UserService } from "@src/items/services/UserService";
 
 const urgencyEmojis = ["⏰", "🚨", "⚠️", "❗", "🧨", "💥"];
 
@@ -47,16 +38,16 @@ export const urgentItemsDirectMessage = async (client: any) => {
       const githubUsername = githubUrl.split("/").pop();
       if (!githubUsername) continue;
 
-      const mapping = githubDiscordMap[githubUsername];
-      if (!mapping || !mapping.discordId) {
+      const userResult = await UserService.findUserByGithubUsername(githubUsername);
+      if (userResult.err || !userResult.val.discordId) {
         logger.warn({
           event: "dailyTasksReminder.missingMapping",
           body: `No Discord ID found for GitHub user: ${githubUsername}`,
         });
         continue;
       }
 
-      const discordId = mapping.discordId;
+      const discordId = userResult.val.discordId;
       const list = groupedByDiscordId.get(discordId) || [];
       list.push({
         title: item.title,

src/infrastructure/discord/webhookMessages.ts

@@ -1,7 +1,7 @@
 import axios from "axios";
 import { Err, Ok, Result } from "ts-results";
 import dotenv from "dotenv";
-import githubDiscordMap from "../../../data/githubDiscordMap.json";
+import { UserService } from "@src/items/services/UserService";
 import { Item } from "../../items";
 import logger from "@config/logger";
 
@@ -57,15 +57,6 @@ export const sendDiscordItemMessage = async (
   }
 };
 
-const githubUrlToDiscordId = (githubUrl: string) => {
-  return githubDiscordMap[
-    githubUrl.replace(
-      "https://github.com/",
-      "",
-    ) as keyof typeof githubDiscordMap
-  ].discordId;
-};
-
 export const formatDiscordDate = (date: Date) => {
   return `<t:${Math.floor(date.getTime() / 1000)}:D>`;
 };
@@ -78,18 +69,17 @@ const formatMessageSectionTitle = (title: string) => {
   return `\n### ${title}: \n`;
 };
 
-const formatDiscordAssignees = (assignees: string[]) => {
-  // TODO: we should filter out the github url before getting to this stuff
-  return assignees
-    .map((assignee) => {
-      const discordId = githubUrlToDiscordId(assignee);
-      if (discordId) {
-        return `<@${discordId}>`;
-      } else {
-        return assignee;
-      }
-    })
-    .join(", ");
+const formatDiscordAssignees = async (assignees: string[]) => {
+  const mentions = await Promise.all(
+    assignees.map(async (githubUrl) => {
+      const githubUsername = githubUrl.replace("https://github.com/", "");
+      const userResult = await UserService.findUserByGithubUsername(githubUsername);
+
+      return userResult.ok ? `<@${userResult.val.discordId}>` : githubUsername;
+    }),
+  );
+
+  return mentions.join(", ");
 };
 
 const formatItem = (item: Item) => {

test/infrastructure/discord/interactions/assigneeSelectInteraction.test.ts

@@ -1,4 +1,6 @@
 import { ItemService } from "@src/items/services";
+import { assigneeSelectInteraction } from "@infrastructure/discord/interactions/assigneeSelectInteraction";
+import { UserService } from "@src/items/services/UserService";
 
 // Define IDs
 const discordId = "147881865548791808";
@@ -12,20 +14,12 @@ jest.mock("@src/items/services", () => ({
   },
 }));
 
-// Use dynamic mocking for githubDiscordMapJson
-beforeAll(() => {
-  jest.doMock("../../../../data/githubDiscordMap.json", () => {
-    return {
-      [githubUsername]: {
-        githubUsername,
-        githubId,
-        discordId,
-      },
-    };
-  });
-});
-
-import { assigneeSelectInteraction } from "@infrastructure/discord/interactions/assigneeSelectInteraction";
+// Manual mock of UserService
+jest.mock("@src/items/services/UserService", () => ({
+  UserService: {
+    findUserByDiscordID: jest.fn(),
+  },
+}));
 
 describe("assigneeSelectInteraction", () => {
   const mockReply = jest.fn();
@@ -58,6 +52,10 @@ describe("assigneeSelectInteraction", () => {
       "not-in-map",
     ]);
 
+    (UserService.findUserByDiscordID as jest.Mock).mockResolvedValue({
+      err: true,
+    });
+
     await assigneeSelectInteraction(interaction as any);
 
     expect(mockReply).toHaveBeenCalledWith({
@@ -69,6 +67,15 @@ describe("assigneeSelectInteraction", () => {
   it("will show error if updateAssignee fails", async () => {
     const interaction = makeInteraction("issue:assignee:select:issue-001");
 
+    (UserService.findUserByDiscordID as jest.Mock).mockResolvedValue({
+      ok: true,
+      val: {
+        githubUsername,
+        githubId,
+        discordId,
+      },
+    });
+
     (ItemService.updateAssignee as jest.Mock).mockResolvedValue({ err: true });
 
     await assigneeSelectInteraction(interaction as any);
@@ -88,6 +95,15 @@ describe("assigneeSelectInteraction", () => {
   it("will update message if assignee update succeeds", async () => {
     const interaction = makeInteraction("issue:assignee:select:issue-002");
 
+    (UserService.findUserByDiscordID as jest.Mock).mockResolvedValue({
+      ok: true,
+      val: {
+        githubUsername,
+        githubId,
+        discordId,
+      },
+    });
+
     (ItemService.updateAssignee as jest.Mock).mockResolvedValue({ err: false });
 
     await assigneeSelectInteraction(interaction as any);

test/infrastructure/discord/tasks/urgentItemsDirecMessage.test.ts

@@ -1,5 +1,6 @@
 import { urgentItemsDirectMessage } from "@infrastructure/discord/tasks/urgentItemsDirectMessage";
 import { GithubAPI } from "@infrastructure/github";
+import { UserService } from "@src/items/services/UserService";
 
 jest.mock("@infrastructure/github", () => ({
   GithubAPI: {
@@ -11,17 +12,11 @@ jest.mock("@infrastructure/discord/webhookMessages", () => ({
   formatDiscordDate: jest.fn((date) => date.toISOString().split("T")[0]),
 }));
 
-jest.mock(
-  "../../../../data/githubDiscordMap.json",
-  () => ({
-    MathyouMB: {
-      githubUsername: "MathyouMB",
-      githubId: "mock-github-id",
-      discordId: "147881865548791808",
-    },
-  }),
-  { virtual: true },
-);
+jest.mock("@src/items/services/UserService", () => ({
+  UserService: {
+    findUserByGithubUsername: jest.fn(),
+  },
+}));
 
 describe("urgentItemsDirectMessage", () => {
   let mockSend: jest.Mock;
@@ -51,6 +46,15 @@ describe("urgentItemsDirectMessage", () => {
       ],
     });
 
+    (UserService.findUserByGithubUsername as jest.Mock).mockResolvedValue({
+      ok: true,
+      val: {
+        githubUsername: "MathyouMB",
+        githubId: "mock-github-id",
+        discordId: "147881865548791808",
+      },
+    });
+
     await urgentItemsDirectMessage(mockClient);
 
     expect(mockClient.users.fetch).toHaveBeenCalledWith("147881865548791808");
@@ -80,6 +84,10 @@ describe("urgentItemsDirectMessage", () => {
       ],
     });
 
+    (UserService.findUserByGithubUsername as jest.Mock).mockResolvedValue({
+      err: true,
+    });
+
     await urgentItemsDirectMessage(mockClient);
 
     expect(mockSend).not.toHaveBeenCalled();