feat(perf): added dataLoading for dynamic events collections

slaveeks · slaveeks · commit 93cad2335dd5 · 2025-11-04T14:17:43.000+03:00
diff --git a/src/dataLoaders.ts b/src/dataLoaders.ts
@@ -1,6 +1,10 @@
 import DataLoader from 'dataloader';
 import { Db, ObjectId } from 'mongodb';
-import { PlanDBScheme, UserDBScheme, WorkspaceDBScheme, ProjectDBScheme } from '@hawk.so/types';
+import { PlanDBScheme, UserDBScheme, WorkspaceDBScheme, ProjectDBScheme, EventData, EventAddons } from '@hawk.so/types';
+
+type EventDbScheme = {
+  _id: ObjectId;
+} & EventData<EventAddons>;
 
 /**
  * Class for setting up data loaders
@@ -14,6 +18,11 @@ export default class DataLoaders {
     { cache: false }
   );
 
+  public eventById = new DataLoader<string, EventDbScheme | null>(
+    (eventIds) => this.batchByIds<EventDbScheme>('events', eventIds),
+    { cache: true }
+  );
+
   /**
    * Loader for fetching workspaces
    */
@@ -65,7 +74,7 @@ export default class DataLoaders {
    * @param collectionName - collection name to get entities
    * @param ids - ids for resolving
    */
-  private async batchByIds<T extends {_id: ObjectId}>(collectionName: string, ids: ReadonlyArray<string>): Promise<(T | null | Error)[]> {
+  private async batchByIds<T extends { _id: ObjectId }>(collectionName: string, ids: ReadonlyArray<string>): Promise<(T | null | Error)[]> {
     return this.batchByField<T, ObjectId>(collectionName, ids.map(id => new ObjectId(id)), '_id');
   }
 
@@ -77,9 +86,9 @@ export default class DataLoaders {
    */
   private async batchByField<
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    T extends {[key: string]: any},
+    T extends { [key: string]: any },
     FieldType extends object | string
-    >(collectionName: string, values: ReadonlyArray<FieldType>, fieldName: string): Promise<(T | null | Error)[]> {
+  >(collectionName: string, values: ReadonlyArray<FieldType>, fieldName: string): Promise<(T | null | Error)[]> {
     const queryResult = await this.dbConnection.collection(collectionName)
       .find({
         [fieldName]: { $in: values },
@@ -99,3 +108,30 @@ export default class DataLoaders {
     return values.map((field) => entitiesMap[field.toString()] || null);
   }
 }
+
+/**
+ * Create DataLoader for events in dynamic collections `events:<projectId>` stored in the events DB
+ * @param eventsDb - MongoDB connection to the events database
+ * @param projectId - project id used to pick a dynamic collection
+ */
+export function createProjectEventsByIdLoader(
+  eventsDb: Db,
+  projectId: string
+): DataLoader<string, EventDbScheme | null> {
+  return new DataLoader<string, EventDbScheme | null>(async (ids) => {
+    const objectIds = ids.map((id) => new ObjectId(id));
+
+    const docs = await eventsDb
+      .collection(`events:${projectId}`)
+      .find({ _id: { $in: objectIds } })
+      .toArray();
+
+    const map: Record<string, EventDbScheme> = {};
+
+    docs.forEach((doc) => {
+      map[doc._id.toString()] = doc as EventDbScheme;
+    });
+
+    return ids.map((id) => map[id] || null);
+  }, { cache: true });
+}
diff --git a/src/index.ts b/src/index.ts
@@ -237,6 +237,7 @@ class HawkAPI {
         id: userId,
         accessTokenExpired: isAccessTokenExpired,
       },
+      eventsFactoryCache: new Map(),
       // accounting,
     };
   }
diff --git a/src/models/eventsFactory.js b/src/models/eventsFactory.js
@@ -1,12 +1,14 @@
 import { getMidnightWithTimezoneOffset, getUTCMidnight } from '../utils/dates';
 import safe from 'safe-regex';
+import { createProjectEventsByIdLoader } from '../dataLoaders';
 
 const Factory = require('./modelFactory');
 const mongo = require('../mongo');
 const Event = require('../models/event');
 const { ObjectID } = require('mongodb');
 const { composeEventPayloadByRepetition } = require('../utils/merge');
 
+
 const MAX_DB_READ_BATCH_SIZE = Number(process.env.MAX_DB_READ_BATCH_SIZE);
 
 /**
@@ -93,7 +95,10 @@ class EventsFactory extends Factory {
       throw new Error('Can not construct Event model, because projectId is not provided');
     }
 
+    console.log('projectId', projectId);
+
     this.projectId = projectId;
+    this.eventById = createProjectEventsByIdLoader(mongo.databases.events, this.projectId);
   }
 
   /**
@@ -135,7 +140,7 @@ class EventsFactory extends Factory {
 
     const cursor = this.getCollection(this.TYPES.EVENTS)
       .find(query)
-      .sort([ ['_id', -1] ])
+      .sort([['_id', -1]])
       .limit(limit)
       .skip(skip);
 
@@ -156,10 +161,7 @@ class EventsFactory extends Factory {
    * @returns {Event|null}
    */
   async findById(id) {
-    const searchResult = await this.getCollection(this.TYPES.EVENTS)
-      .findOne({
-        _id: new ObjectID(id),
-      });
+    const searchResult = await this.eventById.load(id);
 
     const event = searchResult ? new Event(searchResult) : null;
 
@@ -311,7 +313,7 @@ class EventsFactory extends Factory {
       ? Object.fromEntries(
         Object
           .entries(filters)
-          .map(([mark, exists]) => [`event.marks.${mark}`, { $exists: exists } ])
+          .map(([mark, exists]) => [`event.marks.${mark}`, { $exists: exists }])
       )
       : {};
 
@@ -603,10 +605,11 @@ class EventsFactory extends Factory {
      * If originalEventId equals repetitionId than user wants to get first repetition which is original event
      */
     if (repetitionId === originalEventId) {
-      const originalEvent = await this.getCollection(this.TYPES.EVENTS)
-        .findOne({
-          _id: ObjectID(originalEventId),
-        });
+      const originalEvent = await this.eventById.load(originalEventId);
+
+      if (!originalEvent) {
+        return null;
+      }
 
       /**
        * All events have same type with originalEvent id
@@ -626,10 +629,11 @@ class EventsFactory extends Factory {
         _id: ObjectID(repetitionId),
       });
 
-    const originalEvent = await this.getCollection(this.TYPES.EVENTS)
-      .findOne({
-        _id: ObjectID(originalEventId),
-      });
+    const originalEvent = await this.eventById.load(originalEventId);
+
+    if (!originalEvent) {
+      return null;
+    }
 
     /**
      * If one of the ids are invalid (originalEvent or repetition not found) return null
@@ -710,7 +714,7 @@ class EventsFactory extends Factory {
   async toggleEventMark(eventId, mark) {
     const collection = this.getCollection(this.TYPES.EVENTS);
 
-    const event = await this.findById(eventId);
+    const event = await this.eventsDataLoader.eventById.load(eventId);
 
     if (!event) {
       throw new Error(`Event not found for eventId: ${eventId}`);
diff --git a/src/resolvers/event.js b/src/resolvers/event.js
@@ -2,6 +2,25 @@ const EventsFactory = require('../models/eventsFactory');
 const { ObjectID } = require('mongodb');
 const sendPersonalNotification = require('../utils/personalNotifications').default;
 
+/**
+ * Returns a per-request, per-project EventsFactory instance
+ * Uses context.eventsFactoryCache to memoize by projectId
+ * @param {any} context - GraphQL resolver context
+ * @param {string|ObjectID} ctorProjectId - value passed to EventsFactory constructor
+ * @param {string|ObjectID} keyProjectId - value used as cache key (string id is preferred)
+ * @returns {EventsFactory}
+ */
+function getEventsFactoryForProjectId(context, ctorProjectId, keyProjectId) {
+  const cache = context.eventsFactoryCache || (context.eventsFactoryCache = new Map());
+  const cacheKey = (keyProjectId || ctorProjectId).toString();
+
+  if (!cache.has(cacheKey)) {
+    cache.set(cacheKey, new EventsFactory(ctorProjectId));
+  }
+
+  return cache.get(cacheKey);
+}
+
 /**
  * See all types and fields here {@see ../typeDefs/event.graphql}
  */
@@ -29,8 +48,8 @@ module.exports = {
      *
      * @return {RepetitionsPortion}
      */
-    async repetitionsPortion({ projectId, originalEventId }, { limit, cursor }) {
-      const factory = new EventsFactory(projectId);
+    async repetitionsPortion({ projectId, originalEventId }, { limit, cursor }, context) {
+      const factory = getEventsFactoryForProjectId(context, projectId, projectId);
 
       return factory.getEventRepetitions(originalEventId, limit, cursor);
     },
@@ -49,7 +68,7 @@ module.exports = {
       const project = await factories.projectsFactory.findById(projectId);
 
       if (project.workspaceId.toString() === '6213b6a01e6281087467cc7a') {
-        return [ await factories.usersFactory.findById(user.id) ];
+        return [await factories.usersFactory.findById(user.id)];
       }
 
       if (!visitedBy || !visitedBy.length) {
@@ -84,8 +103,8 @@ module.exports = {
      * @param {number} timezoneOffset - user's local timezone offset in minutes
      * @returns {Promise<ProjectChartItem[]>}
      */
-    async chartData({ projectId, groupHash }, { days, timezoneOffset }) {
-      const factory = new EventsFactory(new ObjectID(projectId));
+    async chartData({ projectId, groupHash }, { days, timezoneOffset }, context) {
+      const factory = getEventsFactoryForProjectId(context, new ObjectID(projectId), projectId);
 
       return factory.findChartData(days, timezoneOffset, groupHash);
     },
@@ -97,8 +116,8 @@ module.exports = {
      * @param {String} eventId - event id
      * @returns {Promise<Release>}
      */
-    async release({ projectId, id: eventId }) {
-      const factory = new EventsFactory(new ObjectID(projectId));
+    async release({ projectId, id: eventId }, _args, context) {
+      const factory = getEventsFactoryForProjectId(context, new ObjectID(projectId), projectId);
       const release = await factory.getEventRelease(eventId);
 
       return release;
@@ -114,8 +133,8 @@ module.exports = {
      * @param {UserInContext} user - user context
      * @return {Promise<boolean>}
      */
-    async visitEvent(_obj, { projectId, eventId }, { user }) {
-      const factory = new EventsFactory(projectId);
+    async visitEvent(_obj, { projectId, eventId }, { user, ...context }) {
+      const factory = getEventsFactoryForProjectId(context, projectId, projectId);
 
       const { result } = await factory.visitEvent(eventId, user.id);
 
@@ -131,8 +150,8 @@ module.exports = {
      * @param {string} mark - mark to set
      * @return {Promise<boolean>}
      */
-    async toggleEventMark(_obj, { project, eventId, mark }) {
-      const factory = new EventsFactory(project);
+    async toggleEventMark(_obj, { project, eventId, mark }, context) {
+      const factory = getEventsFactoryForProjectId(context, project, project);
 
       const { result } = await factory.toggleEventMark(eventId, mark);
 
@@ -155,9 +174,9 @@ module.exports = {
      * @param factories - factories for working with models
      * @return {Promise<boolean>}
      */
-    async updateAssignee(_obj, { input }, { factories, user }) {
+    async updateAssignee(_obj, { input }, { factories, user, ...context }) {
       const { projectId, eventId, assignee } = input;
-      const factory = new EventsFactory(projectId);
+      const factory = getEventsFactoryForProjectId(context, projectId, projectId);
 
       const userExists = await factories.usersFactory.findById(assignee);
 
@@ -206,9 +225,9 @@ module.exports = {
      * @param factories - factories for working with models
      * @return {Promise<boolean>}
      */
-    async removeAssignee(_obj, { input }) {
+    async removeAssignee(_obj, { input }, context) {
       const { projectId, eventId } = input;
-      const factory = new EventsFactory(projectId);
+      const factory = getEventsFactoryForProjectId(context, projectId, projectId);
 
       const { result } = await factory.updateAssignee(eventId, '');
 
diff --git a/src/resolvers/project.js b/src/resolvers/project.js
diff --git a/src/types/graphql.ts b/src/types/graphql.ts

Original file line number	Diff line number	Diff line change
`@@ -237,6 +237,7 @@ class HawkAPI {`
`237`	`237`	`id: userId,`
`238`	`238`	`accessTokenExpired: isAccessTokenExpired,`
`239`	`239`	`},`
	`240`	`+ eventsFactoryCache: new Map(),`
`240`	`241`	`// accounting,`
`241`	`242`	`};`
`242`	`243`	`}`