imp(): improved project resolver with dailyEvents

Author: e11sy

src/models/eventsFactory.js

@@ -7,13 +7,6 @@ const mongo = require('../mongo');
 const Event = require('../models/event');
 const { ObjectID } = require('mongodb');
 
-/**
- * @typedef {Object} RecentEventSchema
- * @property {Event} event - event model
- * @property {Number} count - recent error occurred count
- * @property {String} data - error occurred date (string)
- */
-
 /**
  * @typedef {Object} EventRepetitionSchema
  * @property {String} _id — repetition's identifier
@@ -22,6 +15,13 @@ const { ObjectID } = require('mongodb');
  * @property {Number} timestamp - repetition's Unix timestamp
  */
 
+/**
+ * @typedef {Object} DaylyEventsSchema
+ * @property {Event} event - original event of the daily one
+ * @property {EventRepetitionSchema} repetition - last repetition of the day
+ * @property {String | null} nextCursor - pointer to the next dailyEvent for pagination
+ */
+
 /**
  * @typedef {Object} EventsFilters
  * @property {boolean} [starred] - if true, events with 'starred' mark should be included to the output
@@ -148,16 +148,16 @@ class EventsFactory extends Factory {
    * Returns events that grouped by day
    *
    * @param {Number} limit - events count limitations
-   * @param {Number} skip - certain number of documents to skip
+   * @param {String} paginatoinCursor - pointer to the first daily event to be selected
    * @param {'BY_DATE' | 'BY_COUNT'} sort - events sort order
    * @param {EventsFilters} filters - marks by which events should be filtered
    * @param {String} search - Search query
    *
    * @return {RecentEventSchema[]}
    */
-  async findRecent(
+  async findRecentDailyEventsWithEventAndRepetition(
     limit = 10,
-    skip = 0,
+    paginationCursor = '',
     sort = 'BY_DATE',
     filters = {},
     search = ''
@@ -194,6 +194,11 @@ class EventsFactory extends Factory {
 
     const pipeline = [
       {
+        $match: paginationCursor ? {
+          _id: {
+            $gte: new ObjectID(paginationCursor),
+          }
+        } : {},
         $sort: {
           groupingTimestamp: -1,
           [sort]: -1,
@@ -241,6 +246,9 @@ class EventsFactory extends Factory {
       : {};
 
     pipeline.push(
+      /**
+       * Left outer join original event on groupHash field
+       */
       {
         $lookup: {
           from: 'events:' + this.projectId,
@@ -249,48 +257,49 @@ class EventsFactory extends Factory {
           as: 'event',
         },
       },
+      {
+        $lookup: {
+          from: 'repetitions:' + this.projectId,
+          localField: 'lastRepetitionId',
+          foreignField: '_id',
+          as: 'repetition',
+        }
+      },
+      /**
+       * Desctruct event and repetition arrays since there are only one document in both arrays
+       */
       {
         $unwind: '$event',
       },
+      {
+        $unwind: '$repetition',
+      },
       {
         $match: {
           ...matchFilter,
           ...searchFilter,
         },
       },
-      { $skip: skip },
-      { $limit: limit },
+      { $limit: limit + 1 },
       {
-        $group: {
-          _id: null,
-          dailyInfo: { $push: '$$ROOT' },
-          events: { $push: '$event' },
-        },
-      },
-      {
-        $unset: 'dailyInfo.event',
+        $unset: 'groupHash',
       }
     );
 
     const cursor = this.getCollection(this.TYPES.DAILY_EVENTS).aggregate(pipeline);
 
-    const result = (await cursor.toArray()).shift();
+    const result = await cursor.toArray();
 
-    /**
-     * aggregation can return empty array so that
-     * result can be undefined
-     *
-     * for that we check result existence
-     *
-     * extra field `projectId` needs to satisfy GraphQL query
-     */
-    if (result && result.events) {
-      result.events.forEach(event => {
-        event.projectId = this.projectId;
-      });
+    let lastEvent;
+
+    if (result.length === limit + 1) {
+      lastEvent = result.pop();
     }
 
-    return result;
+    return {
+      nextCursor: lastEvent ? lastEvent._id.toString() : null,
+      ...result,
+    };
   }
 
   /**

src/resolvers/project.js

@@ -344,7 +344,7 @@ module.exports = {
      *
      * @return {Promise<RecentEventSchema[]>}
      */
-    async recentEvents(project, { limit, skip, sort, filters, search }) {
+    async dailyEventsPortion(project, { limit, skip, sort, filters, search }) {
       if (search) {
         if (search.length > MAX_SEARCH_QUERY_LENGTH) {
           search = search.slice(0, MAX_SEARCH_QUERY_LENGTH);
@@ -353,7 +353,22 @@ module.exports = {
 
       const factory = new EventsFactory(project._id);
 
-      return factory.findRecent(limit, skip, sort, filters, search);
+      // @todo - rename
+      const res = factory.findRecentDailyEventsWithEventAndRepetition(limit, skip, sort, filters, search);
+
+      res.forEach((dailyEvent) => {
+        const dailyEventLatestRepetition = dailyEvent.repetition;
+        const dailyEventOriginalEvent = dailyEvent.event;
+
+        // wait for util implementation
+        // const mergedRepetition = merge(dailyEventOriginalEvent, dailyEventLatestRepetition);
+        delete dailyEvent.repetition;
+        delete dailyEvent.event;
+
+        // dailyEvent.event = mergedRepetition;
+
+        return dailyEvent;
+      })
     },
 
     /**