feat(events): implement bulkVisitEvents functionality to mark multiple events as visited for a user

Author: Dobrunia

src/models/eventsFactory.js

@@ -882,6 +882,57 @@ class EventsFactory extends Factory {
     return result;
   }
 
+  /**
+   * Mark many original events as visited for passed user
+   *
+   * @param {string[]} eventIds - original event ids
+   * @param {string|ObjectId} userId - id of the user who is visiting events
+   * @returns {Promise<{ updatedCount: number, updatedEventIds: string[], failedEventIds: string[] }>}
+   */
+  async bulkVisitEvent(eventIds, userId) {
+    const unique = [ ...new Set((eventIds || []).map(id => String(id))) ];
+    const failedEventIds = [];
+    const validObjectIds = unique.map(id => new ObjectId(id));
+    const userIdStr = String(userId);
+
+    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 docsToUpdate = found.filter((doc) => {
+      const visitedBy = Array.isArray(doc.visitedBy) ? doc.visitedBy : [];
+      return !visitedBy.some((visitedUserId) => String(visitedUserId) === userIdStr);
+    });
+    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) } },
+      { $addToSet: { visitedBy: new ObjectId(userId) } }
+    );
+
+    return {
+      updatedCount: updateManyResult.modifiedCount,
+      updatedEventIds,
+      failedEventIds,
+    };
+  }
+
   /**
    * Mark or unmark event as Resolved, Ignored or Starred
    *

src/resolvers/event.js

@@ -140,6 +140,34 @@ module.exports = {
 
       return !!result.acknowledged;
     },
+    /**
+     * Mark many original events as visited for current user
+     *
+     * @param {ResolverObj} _obj - resolver context
+     * @param {string} projectId - project id
+     * @param {string[]} eventIds - original event ids
+     * @param {UserInContext} user - user context
+     * @returns {Promise<{ updatedCount: number, updatedEventIds: string[], failedEventIds: string[] }>}
+     */
+    async bulkVisitEvents(_obj, { projectId, eventIds }, { user, ...context }) {
+      const { validEventIds, invalidEventIds } = parseBulkEventIds(eventIds);
+
+      if (validEventIds.length === 0) {
+        return {
+          updatedCount: 0,
+          updatedEventIds: [],
+          failedEventIds: invalidEventIds,
+        };
+      }
+
+      const factory = getEventsFactory(context, projectId);
+      const result = await factory.bulkVisitEvent(validEventIds, user.id);
+
+      return {
+        ...result,
+        failedEventIds: mergeFailedEventIds(result, invalidEventIds),
+      };
+    },
 
     /**
      * Mark event with one of the event marks

src/typeDefs/event.ts

@@ -506,6 +506,26 @@ type BulkToggleEventMarksResult {
   failedEventIds: [ID!]!
 }
 
+"""
+Result of bulk marking events as viewed
+"""
+type BulkVisitEventsResult {
+  """
+  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!]!
+}
+
 type EventsMutations {
   """
   Set an assignee for the selected event
@@ -545,6 +565,21 @@ extend type Mutation {
     eventId: ID!
   ): Boolean!
 
+  """
+  Mark many original events as visited for current user
+  """
+  bulkVisitEvents(
+    """
+    ID of project event is related to
+    """
+    projectId: ID!
+
+    """
+    Original event ids
+    """
+    eventIds: [ID!]!
+  ): BulkVisitEventsResult! @requireUserInWorkspace
+
   """
   Mutation sets or unsets passed mark to event
   """

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

@@ -0,0 +1,82 @@
+import '../../src/env-test';
+import { ObjectId } from 'mongodb';
+
+const collectionMock = {
+  find: jest.fn(),
+  updateMany: jest.fn(),
+};
+
+jest.mock('../../src/redisHelper', () => ({
+  __esModule: true,
+  default: {
+    getInstance: () => ({}),
+  },
+}));
+
+jest.mock('../../src/services/chartDataService', () => ({
+  __esModule: true,
+  default: jest.fn().mockImplementation(function () {
+    return {};
+  }),
+}));
+
+jest.mock('../../src/dataLoaders', () => ({
+  createProjectEventsByIdLoader: () => ({}),
+}));
+
+jest.mock('../../src/mongo', () => ({
+  databases: {
+    events: {
+      collection: jest.fn(() => collectionMock),
+    },
+  },
+}));
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-explicit-any -- CJS class
+const EventsFactory = require('../../src/models/eventsFactory') as any;
+
+describe('EventsFactory.bulkVisitEvent', () => {
+  const projectId = '507f1f77bcf86cd799439011';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    collectionMock.updateMany.mockResolvedValue({ modifiedCount: 0 });
+  });
+
+  it('should mark only not-yet-visited events', async () => {
+    const factory = new EventsFactory(projectId);
+    const a = new ObjectId();
+    const b = new ObjectId();
+    const userId = new ObjectId();
+
+    collectionMock.find.mockReturnValue({
+      toArray: () => Promise.resolve([
+        { _id: a, visitedBy: [ userId ] },
+        { _id: b, visitedBy: [] },
+      ]),
+    });
+    collectionMock.updateMany.mockResolvedValue({ modifiedCount: 1 });
+
+    const result = await factory.bulkVisitEvent([ a.toString(), b.toString() ], userId.toString());
+
+    expect(result.updatedCount).toBe(1);
+    expect(result.updatedEventIds).toEqual([ b.toString() ]);
+    expect(result.failedEventIds).toEqual([]);
+  });
+
+  it('should add not found ids to failedEventIds', async () => {
+    const factory = new EventsFactory(projectId);
+    const missing = new ObjectId();
+
+    collectionMock.find.mockReturnValue({
+      toArray: () => Promise.resolve([]),
+    });
+
+    const result = await factory.bulkVisitEvent([ missing.toString() ], new ObjectId().toString());
+
+    expect(result.updatedCount).toBe(0);
+    expect(result.updatedEventIds).toEqual([]);
+    expect(result.failedEventIds).toEqual([ missing.toString() ]);
+    expect(collectionMock.updateMany).not.toHaveBeenCalled();
+  });
+});

test/resolvers/event-bulk-visit.test.ts

@@ -0,0 +1,70 @@
+import '../../src/env-test';
+
+jest.mock('../../src/resolvers/helpers/eventsFactory', () => ({
+  __esModule: true,
+  default: jest.fn(),
+}));
+
+import getEventsFactory from '../../src/resolvers/helpers/eventsFactory';
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const eventResolvers = require('../../src/resolvers/event') as {
+  Mutation: {
+    bulkVisitEvents: (
+      o: unknown,
+      args: { projectId: string; eventIds: string[] },
+      ctx: any
+    ) => Promise<{ updatedCount: number; updatedEventIds: string[]; failedEventIds: string[] }>;
+  };
+};
+
+const bulkVisitEvent = jest.fn();
+
+describe('Mutation.bulkVisitEvents', () => {
+  const ctx = {
+    user: { id: '507f1f77bcf86cd799439011' },
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (getEventsFactory as unknown as jest.Mock).mockReturnValue({ bulkVisitEvent });
+  });
+
+  it('should call factory with valid ids only and merge invalid ids', async () => {
+    bulkVisitEvent.mockResolvedValue({
+      updatedCount: 1,
+      updatedEventIds: [ '507f1f77bcf86cd799439012' ],
+      failedEventIds: [ '507f1f77bcf86cd799439099' ],
+    });
+
+    const result = await eventResolvers.Mutation.bulkVisitEvents(
+      {},
+      { projectId: 'p1', eventIds: [ '507f1f77bcf86cd799439012', 'bad-id' ] },
+      ctx
+    );
+
+    expect(bulkVisitEvent).toHaveBeenCalledWith(
+      [ '507f1f77bcf86cd799439012' ],
+      '507f1f77bcf86cd799439011'
+    );
+    expect(result).toEqual({
+      updatedCount: 1,
+      updatedEventIds: [ '507f1f77bcf86cd799439012' ],
+      failedEventIds: [ '507f1f77bcf86cd799439099', 'bad-id' ],
+    });
+  });
+
+  it('should return early when all ids are invalid', async () => {
+    const result = await eventResolvers.Mutation.bulkVisitEvents(
+      {},
+      { projectId: 'p1', eventIds: [ 'bad-1', 'bad-2' ] },
+      ctx
+    );
+
+    expect(bulkVisitEvent).not.toHaveBeenCalled();
+    expect(result).toEqual({
+      updatedCount: 0,
+      updatedEventIds: [],
+      failedEventIds: [ 'bad-1', 'bad-2' ],
+    });
+  });
+});