feat(events): extend bulk toggle functionality to support starred marks

Author: Dobrunia

src/models/eventsFactory.js

@@ -926,19 +926,19 @@ class EventsFactory extends Factory {
   }
 
   /**
-   * Bulk mark for resolved / ignored (not the same as per-event toggleEventMark).
+   * 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").
    * - Otherwise: set the mark on every found event that does not have it yet (never remove
    *   from a subset when the selection is mixed).
-   * Only 'resolved' and 'ignored' are allowed for bulk.
+   * Only 'resolved', 'ignored' and 'starred' are allowed for bulk.
    *
    * @param {string[]} eventIds - original event ids
-   * @param {string} mark - 'resolved' | 'ignored'
+   * @param {string} mark - 'resolved' | 'ignored' | 'starred'
    * @returns {Promise<{ updatedCount: number, failedEventIds: string[] }>}
    */
   async bulkToggleEventMark(eventIds, mark) {
-    if (mark !== 'resolved' && mark !== 'ignored') {
-      throw new Error(`bulkToggleEventMark: mark must be resolved or ignored, got ${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;

src/resolvers/event.js

@@ -167,8 +167,8 @@ module.exports = {
      * @return {Promise<{ updatedCount: number, failedEventIds: string[] }>}
      */
     async bulkToggleEventMarks(_obj, { projectId, eventIds, mark }, context) {
-      if (mark !== 'resolved' && mark !== 'ignored') {
-        throw new UserInputError('bulkToggleEventMarks supports only resolved and ignored marks');
+      if (mark !== 'resolved' && mark !== 'ignored' && mark !== 'starred') {
+        throw new UserInputError('bulkToggleEventMarks supports only resolved, ignored and starred marks');
       }
 
       if (!eventIds || !eventIds.length) {

src/typeDefs/event.ts

@@ -520,7 +520,7 @@ extend type Mutation {
   ): Boolean!
 
   """
-  Toggle the same mark on many original events at once (only resolved or ignored).
+  Toggle the same mark on many original events at once (resolved, ignored or starred).
   Same toggle semantics as toggleEventMark per event.
   """
   bulkToggleEventMarks(
@@ -535,7 +535,7 @@ extend type Mutation {
     eventIds: [ID!]!
 
     """
-    Mark (resolved or ignored only): if every selected event already has it, clear it for all;
+    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: EventMark!

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

@@ -49,11 +49,42 @@ describe('EventsFactory.bulkToggleEventMark', () => {
     });
   });
 
-  it('should throw when mark is not resolved or ignored', async () => {
+  it('should throw when mark is unsupported', async () => {
     const factory = new EventsFactory(projectId);
 
-    await expect(factory.bulkToggleEventMark([], 'starred' as any)).rejects.toThrow(
-      'bulkToggleEventMark: mark must be resolved or ignored'
+    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();
+
+    collectionMock.find.mockReturnValue({
+      toArray: () =>
+        Promise.resolve([
+          {
+            _id: id,
+            marks: {},
+          },
+        ]),
+    });
+    collectionMock.bulkWrite.mockResolvedValue({
+      modifiedCount: 1,
+      upsertedCount: 0,
+    });
+
+    const result = await factory.bulkToggleEventMark([ id.toString() ], 'starred');
+
+    expect(result.updatedCount).toBe(1);
+    const ops = collectionMock.bulkWrite.mock.calls[0][0];
+
+    expect(ops).toHaveLength(1);
+    expect(ops[0].updateOne.update).toEqual(
+      expect.objectContaining({
+        $set: { 'marks.starred': expect.any(Number) },
+      })
     );
   });
 

test/resolvers/event-bulk-toggle-marks.test.ts

@@ -29,22 +29,22 @@ describe('Mutation.bulkToggleEventMarks', () => {
     (getEventsFactory as unknown as jest.Mock).mockReturnValue({ bulkToggleEventMark });
   });
 
-  it('should throw when mark is not resolved or ignored', async () => {
+  it('should throw when mark is not supported', async () => {
     await expect(
       eventResolvers.Mutation.bulkToggleEventMarks(
         {},
-        { projectId: 'p1', eventIds: [ '507f1f77bcf86cd799439012' ], mark: 'starred' },
+        { projectId: 'p1', eventIds: [ '507f1f77bcf86cd799439012' ], mark: 'some-unknown-mark' },
         ctx
       )
     ).rejects.toThrow(UserInputError);
 
     await expect(
       eventResolvers.Mutation.bulkToggleEventMarks(
         {},
-        { projectId: 'p1', eventIds: [ '507f1f77bcf86cd799439012' ], mark: 'starred' },
+        { projectId: 'p1', eventIds: [ '507f1f77bcf86cd799439012' ], mark: 'some-unknown-mark' },
         ctx
       )
-    ).rejects.toThrow('bulkToggleEventMarks supports only resolved and ignored marks');
+    ).rejects.toThrow('bulkToggleEventMarks supports only resolved, ignored and starred marks');
 
     expect(bulkToggleEventMark).not.toHaveBeenCalled();
   });
@@ -84,6 +84,28 @@ describe('Mutation.bulkToggleEventMarks', () => {
     expect(result).toEqual(payload);
   });
 
+  it('should allow starred mark for bulk toggle', async () => {
+    const payload = { updatedCount: 1, failedEventIds: [] };
+
+    bulkToggleEventMark.mockResolvedValue(payload);
+
+    const result = await eventResolvers.Mutation.bulkToggleEventMarks(
+      {},
+      {
+        projectId: 'p1',
+        eventIds: [ '507f1f77bcf86cd799439011' ],
+        mark: 'starred',
+      },
+      ctx
+    );
+
+    expect(bulkToggleEventMark).toHaveBeenCalledWith(
+      [ '507f1f77bcf86cd799439011' ],
+      'starred'
+    );
+    expect(result).toEqual(payload);
+  });
+
   it('should map factory max-length error to UserInputError', async () => {
     bulkToggleEventMark.mockRejectedValue(
       new Error('bulkToggleEventMark: at most 100 event ids allowed')