refactor(events): rename bulk toggle event mark methods to bulk set event marks and update related documentation for clarity

Author: Dobrunia

src/models/eventsFactory.js

@@ -940,22 +940,21 @@ class EventsFactory extends Factory {
   }
 
   /**
-   * Bulk toggle mark for original events.
+   * Bulk set or clear mark for original events.
    *
    * @param {string[]} eventIds - original event ids
    * @param {string} mark - 'resolved' | 'ignored' | 'starred'
+   * @param {boolean} enabled - true to set mark, false to clear
    * @returns {Promise<UpdateWriteOpResult>}
    */
-  async bulkToggleEventMark(eventIds, mark) {
+  async bulkSetEventMarks(eventIds, mark, enabled) {
     const uniqueEventIds = [ ...new Set((eventIds || []).map(id => String(id))) ];
     const objectIds = uniqueEventIds.map(id => new ObjectId(id));
     const collection = this.getCollection(this.TYPES.EVENTS);
-    const found = await collection.find({ _id: { $in: objectIds } }).toArray();
     const nowSec = Math.floor(Date.now() / 1000);
     const markKey = `marks.${mark}`;
-    const allHaveMark = found.length > 0 && found.every(doc => doc.marks && doc.marks[mark]);
 
-    if (allHaveMark) {
+    if (!enabled) {
       return collection.updateMany(
         {
           _id: { $in: objectIds },

src/resolvers/event.js

@@ -179,21 +179,21 @@ module.exports = {
     },
 
     /**
-     * Bulk set resolved/ignored: always set mark on events that lack it, unless all selected
-     * already have the mark — then remove from all.
+     * Bulk set or clear mark for original events.
      *
      * @param {ResolverObj} _obj - resolver context
      * @param {string} projectId - project id
      * @param {string[]} eventIds - original event ids
      * @param {string} mark - EventMark enum value
+     * @param {boolean} enabled - true to set mark, false to remove
      * @param {object} context - gql context
      * @return {Promise<{ success: boolean, modifiedCount: number }>}
      */
-    async bulkToggleEventMarks(_obj, { projectId, eventIds, mark }, context) {
+    async bulkSetEventMarks(_obj, { projectId, eventIds, mark, enabled }, context) {
       const validEventIds = parseBulkEventIds(eventIds);
 
       const factory = getEventsFactory(context, projectId);
-      const result = await factory.bulkToggleEventMark(validEventIds, mark);
+      const result = await factory.bulkSetEventMarks(validEventIds, mark, enabled);
 
       return {
         success: !!result.acknowledged,

src/typeDefs/event.ts

@@ -484,7 +484,7 @@ type BulkUpdateAssigneeResponse {
 """
 Response of bulk toggling event marks (resolve / ignore / starred)
 """
-type BulkToggleEventMarksResponse {
+type BulkSetEventMarksResponse {
   """
   True when database accepted mutation
   """
@@ -586,11 +586,9 @@ extend type Mutation {
   ): Boolean!
 
   """
-  Toggle the same mark on many original events at once (resolved, ignored or starred).
-  Uses bulk semantics: if every selected event already has the mark, clear it for all;
-  otherwise set it on each selected event that does not have it yet.
+  Set or clear one mark on many original events at once (resolved, ignored or starred).
   """
-  bulkToggleEventMarks(
+  bulkSetEventMarks(
     """
     Project id
     """
@@ -602,11 +600,15 @@ extend type Mutation {
     eventIds: [ID!]!
 
     """
-    Mark (resolved, ignored or starred): if every selected event already has it, clear it for all;
-    otherwise set it on every selected event that does not have it yet.
+    Mark (resolved, ignored or starred) to update
     """
     mark: EventMark!
-  ): BulkToggleEventMarksResponse! @requireUserInWorkspace
+
+    """
+    True - set mark, false - remove mark
+    """
+    enabled: Boolean!
+  ): BulkSetEventMarksResponse! @requireUserInWorkspace
 
   """
   Namespace that contains only mutations related to the events

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

@@ -2,7 +2,6 @@ import '../../src/env-test';
 import { ObjectId } from 'mongodb';
 
 const collectionMock = {
-  find: jest.fn(),
   updateMany: jest.fn(),
 };
 
@@ -35,7 +34,7 @@ jest.mock('../../src/mongo', () => ({
 // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-explicit-any
 const EventsFactory = require('../../src/models/eventsFactory') as any;
 
-describe('EventsFactory.bulkToggleEventMark', () => {
+describe('EventsFactory.bulkSetEventMarks', () => {
   const projectId = '507f1f77bcf86cd799439011';
 
   beforeEach(() => {
@@ -46,25 +45,16 @@ describe('EventsFactory.bulkToggleEventMark', () => {
     });
   });
 
-  it('should support starred mark', async () => {
+  it('should set starred mark when enabled is true', async () => {
     const factory = new EventsFactory(projectId);
     const id = new ObjectId();
 
-    collectionMock.find.mockReturnValue({
-      toArray: () =>
-        Promise.resolve([
-          {
-            _id: id,
-            marks: {},
-          },
-        ]),
-    });
     collectionMock.updateMany.mockResolvedValue({
       acknowledged: true,
       modifiedCount: 1,
     });
 
-    const result = await factory.bulkToggleEventMark([ id.toString() ], 'starred');
+    const result = await factory.bulkSetEventMarks([ id.toString() ], 'starred', true);
 
     expect(result).toEqual({
       acknowledged: true,
@@ -81,159 +71,51 @@ describe('EventsFactory.bulkToggleEventMark', () => {
     );
   });
 
-  it('should deduplicate duplicate event ids before applying', async () => {
+  it('should clear mark when enabled is false', async () => {
     const factory = new EventsFactory(projectId);
     const id = new ObjectId();
 
-    collectionMock.find.mockReturnValue({
-      toArray: () =>
-        Promise.resolve([
-          {
-            _id: id,
-            marks: {},
-          },
-        ]),
-    });
     collectionMock.updateMany.mockResolvedValue({
       acknowledged: true,
       modifiedCount: 1,
     });
 
-    await factory.bulkToggleEventMark([id.toString(), id.toString(), id.toString()], 'ignored');
-
-    const query = collectionMock.updateMany.mock.calls[0][0];
+    await factory.bulkSetEventMarks([ id.toString() ], 'ignored', false);
 
-    expect(query._id.$in).toHaveLength(1);
+    expect(collectionMock.updateMany).toHaveBeenCalledWith(
+      {
+        _id: { $in: [ id ] },
+        'marks.ignored': { $exists: true },
+      },
+      { $unset: { 'marks.ignored': '' } }
+    );
   });
 
-  it('should return success shape even when nothing changed', async () => {
+  it('should deduplicate duplicate event ids before applying', async () => {
     const factory = new EventsFactory(projectId);
     const id = new ObjectId();
 
-    collectionMock.find.mockReturnValue({
-      toArray: () => Promise.resolve([ {
-        _id: id,
-        marks: { ignored: 1 },
-      } ]),
-    });
-    collectionMock.updateMany.mockResolvedValue({
-      acknowledged: true,
-      modifiedCount: 0,
-    });
+    await factory.bulkSetEventMarks([ id.toString(), id.toString(), id.toString() ], 'ignored', true);
 
-    const result = await factory.bulkToggleEventMark([ id.toString() ], 'ignored');
+    const query = collectionMock.updateMany.mock.calls[0][0];
 
-    expect(result).toEqual({
-      acknowledged: true,
-      modifiedCount: 0,
-    });
+    expect(query._id.$in).toHaveLength(1);
   });
 
-  it('should set mark only on events that do not have it when selection is mixed', async () => {
+  it('should return success shape even when nothing changed', async () => {
     const factory = new EventsFactory(projectId);
-    const a = new ObjectId();
-    const b = new ObjectId();
-
-    collectionMock.find.mockReturnValue({
-      toArray: () =>
-        Promise.resolve([
-          {
-            _id: a,
-            marks: { ignored: 1 },
-          },
-          {
-            _id: b,
-            marks: {},
-          },
-        ]),
-    });
-    collectionMock.updateMany.mockResolvedValue({
-      acknowledged: true,
-      modifiedCount: 1,
-    });
-
-    await factory.bulkToggleEventMark([a.toString(), b.toString()], 'ignored');
-
-    expect(collectionMock.updateMany).toHaveBeenCalledWith(
-      {
-        _id: { $in: [a, b] },
-        'marks.ignored': { $exists: false },
-      },
-      expect.objectContaining({
-        $set: { 'marks.ignored': expect.any(Number) },
-      })
-    );
-  });
+    const id = new ObjectId();
 
-  it('should remove mark from all when every selected event already has the mark', async () => {
-    const factory = new EventsFactory(projectId);
-    const a = new ObjectId();
-    const b = new ObjectId();
-
-    collectionMock.find.mockReturnValue({
-      toArray: () =>
-        Promise.resolve([
-          {
-            _id: a,
-            marks: { resolved: 1 },
-          },
-          {
-            _id: b,
-            marks: { resolved: 2 },
-          },
-        ]),
-    });
     collectionMock.updateMany.mockResolvedValue({
       acknowledged: true,
-      modifiedCount: 2,
+      modifiedCount: 0,
     });
 
-    const result = await factory.bulkToggleEventMark([a.toString(), b.toString()], 'resolved');
+    const result = await factory.bulkSetEventMarks([ id.toString() ], 'ignored', true);
 
     expect(result).toEqual({
       acknowledged: true,
-      modifiedCount: 2,
-    });
-    expect(collectionMock.updateMany).toHaveBeenCalledWith(
-      {
-        _id: { $in: [a, b] },
-        'marks.resolved': { $exists: true },
-      },
-      { $unset: { 'marks.resolved': '' } }
-    );
-  });
-
-  it('should not remove mark from a subset when only some of the found events have the mark', async () => {
-    const factory = new EventsFactory(projectId);
-    const a = new ObjectId();
-    const b = new ObjectId();
-
-    collectionMock.find.mockReturnValue({
-      toArray: () =>
-        Promise.resolve([
-          {
-            _id: a,
-            marks: { ignored: 1 },
-          },
-          {
-            _id: b,
-            marks: {},
-          },
-        ]),
-    });
-    collectionMock.updateMany.mockResolvedValue({
-      acknowledged: true,
-      modifiedCount: 1,
+      modifiedCount: 0,
     });
-
-    await factory.bulkToggleEventMark([a.toString(), b.toString()], 'ignored');
-
-    expect(collectionMock.updateMany).toHaveBeenCalledWith(
-      {
-        _id: { $in: [a, b] },
-        'marks.ignored': { $exists: false },
-      },
-      expect.objectContaining({ $set: { 'marks.ignored': expect.any(Number) } })
-    );
   });
 });

test/models/eventsFactory-bulk-update-assignee.test.ts

@@ -93,4 +93,30 @@ describe('EventsFactory.bulkUpdateAssignee', () => {
       { $set: { assignee: '' } }
     );
   });
+
+  it('should clear assignee when assignee is undefined', async () => {
+    const factory = new EventsFactory(projectId);
+    const a = new ObjectId();
+
+    await factory.bulkUpdateAssignee([ a.toString() ], undefined);
+
+    expect(collectionMock.updateMany).toHaveBeenCalledWith(
+      {
+        _id: { $in: [ a ] },
+        assignee: { $ne: '' },
+      },
+      { $set: { assignee: '' } }
+    );
+  });
+
+  it('should deduplicate duplicate event ids before updateMany', async () => {
+    const factory = new EventsFactory(projectId);
+    const id = new ObjectId();
+
+    await factory.bulkUpdateAssignee([id.toString(), id.toString(), id.toString()], 'user-1');
+
+    const query = collectionMock.updateMany.mock.calls[0][0];
+
+    expect(query._id.$in).toHaveLength(1);
+  });
 });