Add scheduled dm for urgent messages

Author: MathyouMB

src/infrastructure/discord/bot.ts

@@ -7,16 +7,13 @@ import {
   assigneeSelectInteraction,
   issueButtonInteraction,
 } from "./interactions";
+import { schedule } from "./scheduler";
 
 config();
 
 const client = new Client({ intents: [GatewayIntentBits.Guilds] });
 
 const commands = new Map<string, any>();
-const tempIssueData: Record<
-  string,
-  { title: string; description: string; dueDate: string }
-> = {};
 
 // Load slash commands
 const commandFiles = fs.readdirSync(path.join(__dirname, "commands"));
@@ -27,8 +24,9 @@ const commandFiles = fs.readdirSync(path.join(__dirname, "commands"));
   }
 })();
 
-client.once(Events.ClientReady, (c) => {
-  console.log(`✅ Logged in as ${c.user.tag}`);
+client.once(Events.ClientReady, (client) => {
+  console.log(`✅ Logged in as ${client.user.tag}`);
+  schedule(client);
 });
 
 client.on(Events.InteractionCreate, async (interaction) => {

src/infrastructure/discord/scheduler.ts

@@ -0,0 +1,9 @@
+import cron from "node-cron";
+import { Client } from "discord.js";
+import { urgentItemsDirectMessage } from "./tasks/urgentItemsDirectMessage";
+
+export function schedule(client: Client) {
+  cron.schedule("30 8 * * *", async () => {
+    await urgentItemsDirectMessage(client);
+  });
+}

src/infrastructure/discord/tasks/urgentItemsDirectMessage.ts

@@ -0,0 +1,110 @@
+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;
+
+const urgencyEmojis = ["⏰", "🚨", "⚠️", "❗", "🧨", "💥"];
+
+function getRandomUrgencyEmoji() {
+  return urgencyEmojis[Math.floor(Math.random() * urgencyEmojis.length)];
+}
+
+export const urgentItemsDirectMessage = async (client: any) => {
+  logger.info({
+    event: "dailyTasksReminder.start",
+    body: "Running daily task reminder job.",
+  });
+
+  const githubItemsResult = await GithubAPI.fetchProjectItems();
+  if (githubItemsResult.err) {
+    logger.error({
+      event: "dailyTasksReminder.fetchError",
+      body: githubItemsResult.val.message,
+    });
+    return;
+  }
+
+  const nonBacklogItems = filterOutStatus(githubItemsResult.val, "Backlog");
+  const urgentItems = filterForUrgentItems(nonBacklogItems);
+
+  const groupedByDiscordId = new Map<
+    string,
+    { title: string; dueDate?: Date; url?: string; status?: string }[]
+  >();
+
+  for (const item of urgentItems) {
+    for (const githubUrl of item.assignedUsers) {
+      const githubUsername = githubUrl.split("/").pop();
+      if (!githubUsername) continue;
+
+      const mapping = githubDiscordMap[githubUsername];
+      if (!mapping || !mapping.discordId) {
+        logger.warn({
+          event: "dailyTasksReminder.missingMapping",
+          body: `No Discord ID found for GitHub user: ${githubUsername}`,
+        });
+        continue;
+      }
+
+      const discordId = mapping.discordId;
+      const list = groupedByDiscordId.get(discordId) || [];
+      list.push({
+        title: item.title,
+        dueDate: item.dueDate,
+        url: item.url,
+        status: item.status,
+      });
+      groupedByDiscordId.set(discordId, list);
+    }
+  }
+
+  for (const [discordId, issues] of groupedByDiscordId.entries()) {
+    try {
+      const user = await client.users.fetch(discordId);
+      const emoji = getRandomUrgencyEmoji();
+
+      const list = issues
+        .map((item) => {
+          const titleWithLink = item.url
+            ? `[${item.title}](<${item.url}>)`
+            : item.title;
+          const due = item.dueDate ? formatDiscordDate(item.dueDate) : "";
+          const status = item.status ?? "";
+
+          return `\ - ${titleWithLink}${
+            due ? ` - ${due}` : ""
+          }${status ? ` - ${status}` : ""}`;
+        })
+        .join("\n");
+
+      const message = `## ${emoji} You have ${issues.length} urgent issue(s): \n\n${list}\n\n*If you can't meet the deadlines or think they should move, please post in the internal server.*`;
+
+      await user.send(message);
+
+      logger.info({
+        event: "dailyTasksReminder.dmSuccess",
+        body: `Sent DM to ${user.tag} (${discordId})`,
+      });
+    } catch (err) {
+      logger.error({
+        event: "dailyTasksReminder.dmError",
+        body: `Failed to DM user ${discordId}: ${err}`,
+      });
+    }
+  }
+
+  logger.info({
+    event: "dailyTasksReminder.success",
+    body: "Daily tasks reminder sent successfully.",
+  });
+};

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

@@ -0,0 +1,87 @@
+import { urgentItemsDirectMessage } from "@infrastructure/discord/tasks/urgentItemsDirectMessage";
+import { GithubAPI } from "@infrastructure/github";
+
+jest.mock("@infrastructure/github", () => ({
+  GithubAPI: {
+    fetchProjectItems: jest.fn(),
+  },
+}));
+
+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 },
+);
+
+describe("urgentItemsDirectMessage", () => {
+  let mockSend: jest.Mock;
+  let mockClient: any;
+
+  beforeEach(() => {
+    jest.resetModules();
+    mockSend = jest.fn();
+    mockClient = {
+      users: {
+        fetch: jest.fn().mockResolvedValue({ tag: "TestUser", send: mockSend }),
+      },
+    };
+  });
+
+  it("will send a DM to mapped user with urgent issues", async () => {
+    (GithubAPI.fetchProjectItems as jest.Mock).mockResolvedValue({
+      err: false,
+      val: [
+        {
+          title: "Fix bug",
+          assignedUsers: ["https://github.com/MathyouMB"],
+          dueDate: new Date("2025-05-20"),
+          url: "https://github.com/test/test/issues/1",
+          status: "In Progress",
+        },
+      ],
+    });
+
+    await urgentItemsDirectMessage(mockClient);
+
+    expect(mockClient.users.fetch).toHaveBeenCalledWith("147881865548791808");
+    expect(mockSend).toHaveBeenCalledWith(expect.stringContaining("Fix bug"));
+  });
+
+  it("will return early when GitHub fetch fails", async () => {
+    (GithubAPI.fetchProjectItems as jest.Mock).mockResolvedValue({
+      err: true,
+      val: { message: "GitHub error" },
+    });
+
+    await urgentItemsDirectMessage(mockClient);
+
+    expect(mockClient.users.fetch).not.toHaveBeenCalled();
+  });
+
+  it("will skip unmapped GitHub usernames", async () => {
+    (GithubAPI.fetchProjectItems as jest.Mock).mockResolvedValue({
+      err: false,
+      val: [
+        {
+          title: "Unknown user task",
+          assignedUsers: ["https://github.com/UnknownUser"],
+          dueDate: new Date("2025-05-21"),
+        },
+      ],
+    });
+
+    await urgentItemsDirectMessage(mockClient);
+
+    expect(mockSend).not.toHaveBeenCalled();
+  });
+});