imp(): improved project resolver with dailyEvents

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hawk.api",
-  "version": "1.1.30",
+  "version": "1.1.31",
   "main": "index.ts",
   "license": "UNLICENSED",
   "scripts": {

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 = ''
@@ -193,6 +193,13 @@ class EventsFactory extends Factory {
     }
 
     const pipeline = [
+      {
+        $match: paginationCursor ? {
+          _id: {
+            $gte: new ObjectID(paginationCursor),
+          }
+        } : {},
+      },
       {
         $sort: {
           groupingTimestamp: -1,
@@ -241,6 +248,9 @@ class EventsFactory extends Factory {
       : {};
 
     pipeline.push(
+      /**
+       * Left outer join original event on groupHash field
+       */
       {
         $lookup: {
           from: 'events:' + this.projectId,
@@ -249,48 +259,50 @@ 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();
+
+    let lastEvent;
 
-    /**
-     * 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;
-      });
+    if (result.length === limit + 1) {
+      lastEvent = result.pop();
     }
 
-    return result;
+
+    return {
+      nextCursor: lastEvent ? lastEvent._id.toString() : null,
+      dailyEvents: result,
+    };
   }
 
   /**

src/models/projectsFactory.ts

@@ -35,6 +35,8 @@ export default class ProjectsFactory extends AbstractModelFactory<ProjectDBSchem
    * @param id - user id
    */
   public async findById(id: string): Promise<ProjectModel | null> {
+    console.log('id in data loader', id)
+
     const projectData = await this.dataLoaders.projectById.load(id);
 
     if (!projectData) {

src/resolvers/event.js

@@ -61,6 +61,8 @@ module.exports = {
      * @return {Promise<UserModel[]> | null}
      */
     async visitedBy({ visitedBy, projectId }, _args, { factories, user }) {
+      console.log('visitedBy, projectId', visitedBy, projectId)
+
       /**
        * Crutch for Demo Workspace
        */

src/resolvers/project.js

@@ -8,6 +8,7 @@ const EventsFactory = require('../models/eventsFactory');
 const ProjectToWorkspace = require('../models/projectToWorkspace');
 const { dateFromObjectId } = require('../utils/dates');
 const ProjectModel = require('../models/project').default;
+const { composeFullRepetitionEvent } = require('../utils/merge');
 
 const EVENTS_GROUP_HASH_INDEX_NAME = 'groupHashUnique';
 const REPETITIONS_GROUP_HASH_INDEX_NAME = 'groupHash_hashed';
@@ -289,6 +290,7 @@ module.exports = {
      */
     async event(project, { id: eventId }) {
       const factory = new EventsFactory(project._id);
+
       const event = await factory.findById(eventId);
 
       if (!event) {
@@ -344,7 +346,7 @@ module.exports = {
      *
      * @return {Promise<RecentEventSchema[]>}
      */
-    async recentEvents(project, { limit, skip, sort, filters, search }) {
+    async dailyEventsPortion(project, { limit, cursor, sort, filters, search }) {
       if (search) {
         if (search.length > MAX_SEARCH_QUERY_LENGTH) {
           search = search.slice(0, MAX_SEARCH_QUERY_LENGTH);
@@ -353,7 +355,29 @@ module.exports = {
 
       const factory = new EventsFactory(project._id);
 
-      return factory.findRecent(limit, skip, sort, filters, search);
+      const dailyEventsPortion = await factory.findRecentDailyEventsWithEventAndRepetition(limit, cursor, sort, filters, search);
+
+      dailyEventsPortion.dailyEvents.forEach((dailyEvent) => {
+        const dailyEventLatestRepetition = dailyEvent.repetition;
+        const dailyEventOriginalEvent = dailyEvent.event;
+
+        const mergedRepetition = composeFullRepetitionEvent(dailyEventOriginalEvent, dailyEventLatestRepetition);
+        const stringifiedId = dailyEvent._id.toString();
+
+
+        delete dailyEvent.repetition;
+        delete dailyEvent.event;
+        delete dailyEvent._id;
+
+        dailyEvent.event = mergedRepetition;
+        dailyEvent.id = stringifiedId;
+
+        return dailyEvent;
+      })
+
+      console.log('daily events portion composed, ...[event]', dailyEventsPortion);
+
+      return dailyEventsPortion;
     },
 
     /**

src/typeDefs/project.ts

@@ -11,6 +11,47 @@ enum EventsSortOrder {
   BY_AFFECTED_USERS
 }
 
+"""
+Pagination cursor of events portion and list of daily events
+"""
+type DailyEventsPortion {
+  """
+  Cursor to the next portion of the events, null if there are no events left
+  """
+  nextCursor: String
+
+  """
+  Daily event information
+  """
+  dailyEvents: [DailyEvent]
+}
+
+"""
+Daily event information with event itself
+"""
+type DailyEvent {
+  """
+  ID of the daily event
+  """
+  id: ID!
+  """
+  Count of events in this day
+  """
+  count: Int!
+  """
+  Count of the users affected by this event in this day
+  """
+  affectedUsers: Int!
+  """
+  Timestamp of the event grouping
+  """
+  groupingTimestamp: Int!
+  """
+  Event itself
+  """
+  event: Event!
+}
+
 """
 Events filters input type
 """
@@ -128,6 +169,36 @@ type Project {
     "Search query"
     search: String
   ): RecentEvents
+  """
+  Portion of daily events
+  """
+  dailyEventsPortion(
+    """
+    Maximum number of results
+    """
+    limit: Int! = 50
+
+    """
+    Next Cursor to fetch next portion of events
+    """
+    nextCursor: String
+
+    """
+    Events sort order
+    """
+    sort: EventsSortOrder = lastRepetitionTime
+
+    """
+    Event marks by which events should be sorted
+    """
+    filters: EventsFiltersInput
+
+    """
+    Search query
+    """
+    search: String
+  ): DailyEventsPortion
+
   """
   Return events that occurred after a certain timestamp
   """