Refactor: Update fetchIncompleteTasksByUserIds to use batch queries and filter in-memory

- Replaced Firestore query with batch query to fetch incomplete tasks for multiple users at once.
- Filter tasks by user IDs and completed statuses in-memory for improved efficiency.
- Updated return structure to return an array directly instead of an object with `docs` property.
- Updated test cases related to the same.

Author: VinuB-Dev

models/tasks.js

@@ -702,21 +702,28 @@ const markUnDoneTasksOfArchivedUsersBacklog = async (users) => {
 };
 
 /**
- * Fetch incomplete tasks assigned to a specific user
- * @param {string} userId - The unique identifier for the user.
- * @returns {Promise<Array>} - A promise that resolves to an array of incomplete tasks for the given user.
+ * Fetches all incomplete tasks for given user IDs.
+ *
+ * @param {string[]} userIds - The IDs of the users to fetch incomplete tasks for.
+ * @returns {Promise<firebase.firestore.QuerySnapshot>} - The query snapshot object.
  * @throws {Error} - Throws an error if the database query fails.
  */
-const fetchIncompleteTaskForUser = async (userId) => {
+const fetchIncompleteTasksByUserIds = async (userIds) => {
   const COMPLETED_STATUSES = [DONE, COMPLETED];
+
+  if (!userIds || userIds.length === 0) {
+    return [];
+  }
   try {
-    const incompleteTaskForUser = await tasksModel
-      .where("assigneeId", "==", userId)
-      .where("status", "not-in", COMPLETED_STATUSES)
-      .get();
-    return incompleteTaskForUser;
+    const incompleteTasksQuery = await tasksModel.where("assigneeId", "in", userIds).get();
+
+    const incompleteTaskForUsers = incompleteTasksQuery.docs.filter(
+      (task) => !COMPLETED_STATUSES.includes(task.data().status)
+    );
+
+    return incompleteTaskForUsers;
   } catch (error) {
-    logger.error("Error when fetching incomplete tasks:", error);
+    logger.error("Error when fetching incomplete tasks for users:", error);
     throw error;
   }
 };
@@ -740,5 +747,5 @@ module.exports = {
   updateTaskStatus,
   updateOrphanTasksStatus,
   markUnDoneTasksOfArchivedUsersBacklog,
-  fetchIncompleteTaskForUser,
+  fetchIncompleteTasksByUserIds,
 };

services/users.js

@@ -1,21 +1,27 @@
 const firestore = require("../utils/firestore");
 const { formatUsername } = require("../utils/username");
 const userModel = firestore.collection("users");
-const tasksQuery = require("../models/tasks");
+const tasksModel = require("../models/tasks");
 
 const getUsersWithIncompleteTasks = async (users) => {
   if (users.length === 0) return [];
+
   try {
-    const eligibleUsersWithTasks = [];
-    for (const user of users) {
-      const abandonedTasksQuerySnapshot = await tasksQuery.fetchIncompleteTaskForUser(user.id);
-      if (!abandonedTasksQuerySnapshot.empty) {
-        eligibleUsersWithTasks.push(user);
-      }
+    const userIds = users.map((user) => user.id);
+
+    const abandonedTasksQuerySnapshot = await tasksModel.fetchIncompleteTasksByUserIds(userIds);
+
+    if (abandonedTasksQuerySnapshot.empty) {
+      return [];
     }
+
+    const userIdsWithIncompleteTasks = new Set(abandonedTasksQuerySnapshot.map((doc) => doc.data().assigneeId));
+
+    const eligibleUsersWithTasks = users.filter((user) => userIdsWithIncompleteTasks.has(user.id));
+
     return eligibleUsersWithTasks;
   } catch (error) {
-    logger.error(`Error in getting users who abandoned tasks:  ${error}`);
+    logger.error(`Error in getting users who abandoned tasks: ${error}`);
     throw error;
   }
 };

test/unit/models/tasks.test.js

@@ -371,23 +371,23 @@ describe("tasks", function () {
     });
 
     it("should fetch tasks which are incomplete for the given user", async function () {
-      const inactiveUser = abandonedUsersData[0];
-      const incompleteTasks = await tasks.fetchIncompleteTaskForUser(inactiveUser.id);
-      expect(incompleteTasks.docs.length).to.be.equal(1);
+      const userIds = abandonedUsersData.map((user) => user.id);
+      const incompleteTasks = await tasks.fetchIncompleteTasksByUserIds(userIds);
+      expect(incompleteTasks.length).to.be.equal(3);
     });
 
     it("should return an empty array if there are no tasks incomplete for the user", async function () {
       await cleanDb();
       const activeUser = abandonedUsersData[2];
-      const incompleteTasks = await tasks.fetchIncompleteTaskForUser(activeUser.id);
-      expect(incompleteTasks.docs.length).to.be.equal(0);
+      const incompleteTasks = await tasks.fetchIncompleteTasksByUserIds([activeUser.id]);
+      expect(incompleteTasks.length).to.be.equal(0);
     });
 
     it("should handle errors gracefully if the database query fails", async function () {
-      sinon.stub(tasks, "fetchIncompleteTaskForUser").throws(new Error("Database query failed"));
+      sinon.stub(tasks, "fetchIncompleteTasksByUserIds").throws(new Error("Database query failed"));
 
       try {
-        await tasks.fetchIncompleteTaskForUser();
+        await tasks.fetchIncompleteTasksByUserIds();
         expect.fail("Expected function to throw an error");
       } catch (error) {
         expect(error.message).to.equal("Database query failed");

test/unit/services/users.test.js

@@ -150,7 +150,7 @@ describe("Users services", function () {
 
     it("should throw an error if fetchIncompleteTaskForUser fails", async function () {
       const users = abandonedUsersData.slice(0, 2);
-      Sinon.stub(tasks, "fetchIncompleteTaskForUser").throws(new Error("Database query failed"));
+      Sinon.stub(tasks, "fetchIncompleteTasksByUserIds").throws(new Error("Database query failed"));
 
       try {
         await getUsersWithIncompleteTasks([users]);