feat(events): add bulkUpdateAssignee functionality to manage event assignees

Author: Dobrunia

src/models/eventsFactory.js

@@ -918,13 +918,6 @@ class EventsFactory extends Factory {
     return collection.updateOne(query, update);
   }
 
-  /**
-   * Max original event ids per bulkToggleEventMark request
-   */
-  static get BULK_TOGGLE_EVENT_MARK_MAX() {
-    return 100;
-  }
-
   /**
    * Bulk mark for resolved / ignored / starred (not the same as per-event toggleEventMark).
    * - If every found event already has the mark: remove it from all (bulk "undo").
@@ -937,17 +930,8 @@ class EventsFactory extends Factory {
    * @returns {Promise<{ updatedCount: number, updatedEventIds: string[], failedEventIds: string[] }>}
    */
   async bulkToggleEventMark(eventIds, mark) {
-    if (mark !== 'resolved' && mark !== 'ignored' && mark !== 'starred') {
-      throw new Error(`bulkToggleEventMark: mark must be resolved, ignored or starred, got ${mark}`);
-    }
-
-    const max = EventsFactory.BULK_TOGGLE_EVENT_MARK_MAX;
     const unique = [ ...new Set((eventIds || []).map(id => String(id))) ];
 
-    if (unique.length > max) {
-      throw new Error(`bulkToggleEventMark: at most ${max} event ids allowed`);
-    }
-
     const failedEventIds = [];
     const validObjectIds = [];
 
@@ -1023,6 +1007,70 @@ class EventsFactory extends Factory {
     };
   }
 
+  /**
+   * Bulk set/clear assignee for many original events.
+   *
+   * @param {string[]} eventIds - original event ids
+   * @param {string|null|undefined} assignee - target assignee id, null/undefined to clear
+   * @returns {Promise<{ updatedCount: number, updatedEventIds: string[], failedEventIds: string[] }>}
+   */
+  async bulkUpdateAssignee(eventIds, assignee) {
+    const unique = [ ...new Set((eventIds || []).map(id => String(id))) ];
+    const failedEventIds = [];
+    const validObjectIds = [];
+
+    for (const id of unique) {
+      if (!ObjectId.isValid(id)) {
+        failedEventIds.push(id);
+      } else {
+        validObjectIds.push(new ObjectId(id));
+      }
+    }
+
+    if (validObjectIds.length === 0) {
+      return {
+        updatedCount: 0,
+        updatedEventIds: [],
+        failedEventIds,
+      };
+    }
+
+    const collection = this.getCollection(this.TYPES.EVENTS);
+    const found = await collection.find({ _id: { $in: validObjectIds } }).toArray();
+    const foundByIdStr = new Map(found.map(doc => [doc._id.toString(), doc]));
+
+    for (const oid of validObjectIds) {
+      const idStr = oid.toString();
+
+      if (!foundByIdStr.has(idStr)) {
+        failedEventIds.push(idStr);
+      }
+    }
+
+    const normalizedAssignee = assignee ? String(assignee) : '';
+    const docsToUpdate = found.filter(doc => String(doc.assignee || '') !== normalizedAssignee);
+    const updatedEventIds = docsToUpdate.map(doc => doc._id.toString());
+
+    if (docsToUpdate.length === 0) {
+      return {
+        updatedCount: 0,
+        updatedEventIds: [],
+        failedEventIds,
+      };
+    }
+
+    const updateManyResult = await collection.updateMany(
+      { _id: { $in: docsToUpdate.map(doc => doc._id) } },
+      { $set: { assignee: normalizedAssignee } }
+    );
+
+    return {
+      updatedCount: updateManyResult.modifiedCount,
+      updatedEventIds,
+      failedEventIds,
+    };
+  }
+
   /**
    * Remove all project events
    *

src/resolvers/event.js

@@ -3,6 +3,37 @@ const sendPersonalNotification = require('../utils/personalNotifications').defau
 const { aiService } = require('../services/ai');
 const { UserInputError } = require('apollo-server-express');
 
+/**
+ * Enqueue assignee notifications in background (do not block resolver response)
+ *
+ * @param {object} args - notification args
+ * @param {object} args.assigneeData - assigned user data
+ * @param {string[]} args.eventIds - original event ids
+ * @param {string} args.projectId - project id
+ * @param {string} args.assigneeId - assignee id
+ * @param {string} args.whoAssignedId - user id who performed assignment
+ * @returns {void}
+ */
+function fireAndForgetAssigneeNotifications({
+  assigneeData,
+  eventIds,
+  projectId,
+  assigneeId,
+  whoAssignedId,
+}) {
+  void Promise.allSettled(eventIds.map(eventId => sendPersonalNotification(assigneeData, {
+    type: 'assignee',
+    payload: {
+      assigneeId,
+      projectId,
+      whoAssignedId,
+      eventId,
+    },
+  }))).catch((error) => {
+    console.error('Failed to enqueue assignee notifications', error);
+  });
+}
+
 /**
  * See all types and fields here {@see ../typeDefs/event.graphql}
  */
@@ -163,7 +194,7 @@ module.exports = {
      * @param {string[]} eventIds - original event ids
      * @param {string} mark - EventMark enum value
      * @param {object} context - gql context
-     * @return {Promise<{ updatedCount: number, failedEventIds: string[] }>}
+     * @return {Promise<{ updatedCount: number, updatedEventIds: string[], failedEventIds: string[] }>}
      */
     async bulkToggleEventMarks(_obj, { projectId, eventIds, mark }, context) {
       if (mark !== 'resolved' && mark !== 'ignored' && mark !== 'starred') {
@@ -176,15 +207,7 @@ module.exports = {
 
       const factory = getEventsFactory(context, projectId);
 
-      try {
-        return await factory.bulkToggleEventMark(eventIds, mark);
-      } catch (err) {
-        if (err.message && err.message.includes('bulkToggleEventMark: at most')) {
-          throw new UserInputError(err.message);
-        }
-
-        throw err;
-      }
+      return factory.bulkToggleEventMark(eventIds, mark);
     },
 
     /**
@@ -230,14 +253,12 @@ module.exports = {
 
       const assigneeData = await factories.usersFactory.dataLoaders.userById.load(assignee);
 
-      await sendPersonalNotification(assigneeData, {
-        type: 'assignee',
-        payload: {
-          assigneeId: assignee,
-          projectId,
-          whoAssignedId: user.id,
-          eventId,
-        },
+      fireAndForgetAssigneeNotifications({
+        assigneeData,
+        eventIds: [ eventId ],
+        projectId,
+        assigneeId: assignee,
+        whoAssignedId: user.id,
       });
 
       return {
@@ -264,5 +285,58 @@ module.exports = {
         success: !!result.acknowledged,
       };
     },
+
+    /**
+     * Bulk set/clear assignee for selected original events
+     *
+     * @param {ResolverObj} _obj - resolver context
+     * @param {BulkUpdateAssigneeInput} input - object of arguments
+     * @param factories - factories for working with models
+     * @return {Promise<{ updatedCount: number, updatedEventIds: string[], failedEventIds: string[] }>}
+     */
+    async bulkUpdateAssignee(_obj, { input }, { factories, user, ...context }) {
+      const { projectId, eventIds, assignee } = input;
+      const factory = getEventsFactory(context, projectId);
+
+      if (!eventIds || !eventIds.length) {
+        throw new UserInputError('eventIds must contain at least one id');
+      }
+
+      if (assignee) {
+        const userExists = await factories.usersFactory.findById(assignee);
+
+        if (!userExists) {
+          throw new UserInputError('assignee not found');
+        }
+
+        const project = await factories.projectsFactory.findById(projectId);
+        const workspace = await factories.workspacesFactory.findById(project.workspaceId);
+        const assigneeExistsInWorkspace = await workspace.getMemberInfo(assignee);
+
+        if (!assigneeExistsInWorkspace) {
+          throw new UserInputError('assignee is not a workspace member');
+        }
+      }
+
+      const result = await factory.bulkUpdateAssignee(eventIds, assignee);
+
+      if (assignee && result.updatedEventIds.length > 0) {
+        void factories.usersFactory.dataLoaders.userById.load(assignee)
+          .then((assigneeData) => {
+            fireAndForgetAssigneeNotifications({
+              assigneeData,
+              eventIds: result.updatedEventIds,
+              projectId,
+              assigneeId: assignee,
+              whoAssignedId: user.id,
+            });
+          })
+          .catch((error) => {
+            console.error('Failed to load assignee data for bulk notifications', error);
+          });
+      }
+
+      return result;
+    },
   },
 };

src/typeDefs/event.ts

@@ -445,13 +445,47 @@ input RemoveAssigneeInput {
   eventId: ID!
 }
 
+input BulkUpdateAssigneeInput {
+  """
+  ID of project event is related to
+  """
+  projectId: ID!
+
+  """
+  Original event ids to update
+  """
+  eventIds: [ID!]!
+
+  """
+  Assignee id to set. Pass null to clear assignee.
+  """
+  assignee: ID
+}
+
 type RemoveAssigneeResponse {
   """
   Response status
   """
   success: Boolean!
 }
 
+type BulkUpdateAssigneeResponse {
+  """
+  Number of events updated in the database
+  """
+  updatedCount: Int!
+
+  """
+  Original event ids actually updated in this operation
+  """
+  updatedEventIds: [ID!]!
+
+  """
+  Event ids that were not updated (invalid id or not found)
+  """
+  failedEventIds: [ID!]!
+}
+
 """
 Result of bulk toggling event marks (resolve / ignore)
 """
@@ -486,6 +520,13 @@ type EventsMutations {
   removeAssignee(
     input: RemoveAssigneeInput!
   ): RemoveAssigneeResponse!  @requireUserInWorkspace
+
+  """
+  Bulk set/clear assignee on many original events
+  """
+  bulkUpdateAssignee(
+    input: BulkUpdateAssigneeInput!
+  ): BulkUpdateAssigneeResponse! @requireUserInWorkspace
 }
 
 extend type Mutation {

test/models/eventsFactory-bulk-toggle.test.ts

@@ -49,14 +49,6 @@ describe('EventsFactory.bulkToggleEventMark', () => {
     });
   });
 
-  it('should throw when mark is unsupported', async () => {
-    const factory = new EventsFactory(projectId);
-
-    await expect(factory.bulkToggleEventMark([], 'some-unknown-mark' as any)).rejects.toThrow(
-      'bulkToggleEventMark: mark must be resolved, ignored or starred'
-    );
-  });
-
   it('should support starred mark', async () => {
     const factory = new EventsFactory(projectId);
     const id = new ObjectId();
@@ -89,16 +81,6 @@ describe('EventsFactory.bulkToggleEventMark', () => {
     );
   });
 
-  it('should reject more than BULK_TOGGLE_EVENT_MARK_MAX unique ids', async () => {
-    const factory = new EventsFactory(projectId);
-    const max = EventsFactory.BULK_TOGGLE_EVENT_MARK_MAX;
-    const ids = Array.from({ length: max + 1 }, (_, i) => `id-${i}`);
-
-    await expect(factory.bulkToggleEventMark(ids, 'ignored')).rejects.toThrow(
-      `bulkToggleEventMark: at most ${max} event ids allowed`
-    );
-  });
-
   it('should deduplicate duplicate event ids before applying', async () => {
     const factory = new EventsFactory(projectId);
     const id = new ObjectId();