Feat/events multiselect bulk actions

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hawk.api",
-  "version": "1.4.13",
+  "version": "1.5.0",
   "main": "index.ts",
   "license": "BUSL-1.1",
   "scripts": {

src/models/eventsFactory.js

@@ -882,6 +882,27 @@ 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<UpdateWriteOpResult>}
+   */
+  async bulkVisitEvents(eventIds, userId) {
+    const uniqueEventIds = [ ...new Set((eventIds || []).map(id => String(id))) ];
+    const collection = this.getCollection(this.TYPES.EVENTS);
+    const userObjectId = new ObjectId(userId);
+
+    return collection.updateMany(
+      {
+        _id: { $in: uniqueEventIds.map(id => new ObjectId(id)) },
+        visitedBy: { $ne: userObjectId },
+      },
+      { $addToSet: { visitedBy: userObjectId } }
+    );
+  }
+
   /**
    * Mark or unmark event as Resolved, Ignored or Starred
    *
@@ -918,6 +939,61 @@ class EventsFactory extends Factory {
     return collection.updateOne(query, update);
   }
 
+  /**
+   * 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 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 nowSec = Math.floor(Date.now() / 1000);
+    const markKey = `marks.${mark}`;
+
+    if (!enabled) {
+      return collection.updateMany(
+        {
+          _id: { $in: objectIds },
+          [markKey]: { $exists: true },
+        },
+        { $unset: { [markKey]: '' } }
+      );
+    }
+
+    return collection.updateMany(
+      {
+        _id: { $in: objectIds },
+        [markKey]: { $exists: false },
+      },
+      { $set: { [markKey]: nowSec } }
+    );
+  }
+
+  /**
+   * 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<UpdateWriteOpResult>}
+   */
+  async bulkUpdateAssignee(eventIds, assignee) {
+    const uniqueEventIds = [ ...new Set((eventIds || []).map(id => String(id))) ];
+    const collection = this.getCollection(this.TYPES.EVENTS);
+    const normalizedAssignee = assignee ? String(assignee) : '';
+
+    return collection.updateMany(
+      {
+        _id: { $in: uniqueEventIds.map(id => new ObjectId(id)) },
+        assignee: { $ne: normalizedAssignee },
+      },
+      { $set: { assignee: normalizedAssignee } }
+    );
+  }
+
   /**
    * Remove a single event and all related data (repetitions, daily events)
    *

src/resolvers/event.js

@@ -1,6 +1,11 @@
 const getEventsFactory = require('./helpers/eventsFactory').default;
-const sendPersonalNotification = require('../utils/personalNotifications').default;
+const {
+  parseBulkEventIds,
+  enqueueAssigneeNotification,
+} = require('./helpers/bulkEventUtils');
 const { aiService } = require('../services/ai');
+const { UserInputError } = require('apollo-server-express');
+const { ObjectId } = require('mongodb');
 
 /**
  * See all types and fields here {@see ../typeDefs/event.graphql}
@@ -135,6 +140,26 @@ 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<{ success: boolean, modifiedCount: number }>}
+     */
+    async bulkVisitEvents(_obj, { projectId, eventIds }, { user, ...context }) {
+      const validEventIds = parseBulkEventIds(eventIds);
+
+      const factory = getEventsFactory(context, projectId);
+      const result = await factory.bulkVisitEvents(validEventIds, user.id);
+
+      return {
+        success: !!result.acknowledged,
+        modifiedCount: result.modifiedCount || 0,
+      };
+    },
 
     /**
      * Mark event with one of the event marks
@@ -153,6 +178,29 @@ module.exports = {
       return !!result.acknowledged;
     },
 
+    /**
+     * 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 bulkSetEventMarks(_obj, { projectId, eventIds, mark, enabled }, context) {
+      const validEventIds = parseBulkEventIds(eventIds);
+
+      const factory = getEventsFactory(context, projectId);
+      const result = await factory.bulkSetEventMarks(validEventIds, mark, enabled);
+
+      return {
+        success: !!result.acknowledged,
+        modifiedCount: result.modifiedCount || 0,
+      };
+    },
+
     /**
      * Remove event and all related data (repetitions, daily events)
      *
@@ -212,14 +260,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,
-        },
+      enqueueAssigneeNotification({
+        assigneeData,
+        assigneeId: assignee,
+        projectId,
+        whoAssignedId: user.id,
+        eventId,
       });
 
       return {
@@ -246,5 +292,62 @@ 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<{ success: boolean, modifiedCount: number }>}
+     */
+    async bulkUpdateAssignee(_obj, { input }, { factories, user, ...context }) {
+      const { projectId, eventIds, assignee } = input;
+      const validEventIds = parseBulkEventIds(eventIds);
+      let assigneeData = null;
+
+      const factory = getEventsFactory(context, projectId);
+
+      if (assignee) {
+        if (!ObjectId.isValid(String(assignee))) {
+          throw new UserInputError('assignee must be a valid id or null');
+        }
+
+        const userExists = await factories.usersFactory.findById(assignee);
+
+        if (!userExists) {
+          throw new UserInputError('assignee not found');
+        }
+
+        assigneeData = userExists;
+
+        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(validEventIds, assignee);
+
+      if (assignee && result.modifiedCount > 0) {
+        validEventIds.forEach((eventId) => {
+          enqueueAssigneeNotification({
+            assigneeData,
+            assigneeId: assignee,
+            projectId,
+            whoAssignedId: user.id,
+            eventId,
+          });
+        });
+      }
+
+      return {
+        success: !!result.acknowledged,
+        modifiedCount: result.modifiedCount || 0,
+      };
+    },
   },
 };

src/resolvers/helpers/bulkEventUtils.ts

@@ -0,0 +1,52 @@
+import { UserInputError } from 'apollo-server-express';
+import { ObjectId } from 'mongodb';
+import sendPersonalNotification from '../../utils/personalNotifications';
+import { SenderWorkerTaskType } from '../../types/userNotifications/task-type';
+import type { EnqueueAssigneeNotificationParams } from '../../types/userNotifications/assignee';
+
+/**
+ * Validate and normalize bulk event ids from resolver input.
+ *
+ * @param {string[]} eventIds - raw event ids from GraphQL input
+ * @returns {string[]} unique valid event ids
+ */
+export function parseBulkEventIds(eventIds: string[]): string[] {
+  if (!eventIds || !eventIds.length) {
+    throw new UserInputError('eventIds must contain at least one id');
+  }
+
+  const uniqueEventIds = [ ...new Set(eventIds.map(id => String(id))) ];
+
+  if (!uniqueEventIds.every((id) => ObjectId.isValid(id))) {
+    throw new UserInputError('eventIds must contain only valid ids');
+  }
+
+  return uniqueEventIds;
+}
+
+/**
+ * Enqueue one assignee notification without blocking resolver response.
+ */
+export function enqueueAssigneeNotification({
+  assigneeData,
+  assigneeId,
+  projectId,
+  whoAssignedId,
+  eventId,
+}: EnqueueAssigneeNotificationParams): void {
+  if (!assigneeData) {
+    return;
+  }
+
+  sendPersonalNotification(assigneeData, {
+    type: SenderWorkerTaskType.Assignee,
+    payload: {
+      assigneeId,
+      projectId,
+      whoAssignedId,
+      eventId,
+    },
+  }).catch((error: unknown) => {
+    console.error('Failed to enqueue assignee notification', error);
+  });
+}