fix: working state

novuhq · scopsy · Dec 4, 2024 · Dec 4, 2024 · Dec 4, 2024 · Dec 4, 2024
commit 4c9bd12f54994f2f166f13125991349dbb40cbef
diff --git a/apps/api/src/app/insights/services/metrics-calculator.service.ts b/apps/api/src/app/insights/services/metrics-calculator.service.ts
@@ -1,15 +1,16 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { startOfDay, formatISO } from 'date-fns';
+import { ChannelTypeEnum } from '@novu/shared';
 import {
   IDateRange,
   ISeriesData,
-  IInboxResponse,
+  IMixpanelInboxResponse,
   IInboxMetrics,
   IOrganizationMetrics,
-  IMixpanelResponse,
+  IMixpanelTriggerResponse,
   IMetricStats,
-  MixpanelSeriesNameEnum,
   IChannelData,
+  MixpanelInboxSeriesNameEnum,
 } from '../types/usage-insights.types';
 
 @Injectable()
@@ -52,15 +53,24 @@ export class MetricsCalculatorService {
   }
 
   calculateInboxMetrics(
-    inboxSeries: IInboxResponse['series'],
-    inboxTimeComparison: IInboxResponse['time_comparison']['series'],
-    orgId: string,
-    dateRange: IDateRange
+    inboxSeries?: Record<MixpanelInboxSeriesNameEnum, IChannelData>,
+    inboxTimeComparison?: Record<MixpanelInboxSeriesNameEnum, IChannelData>,
+    orgId?: string,
+    dateRange?: IDateRange
   ): IInboxMetrics {
-    Logger.debug(`Calculating inbox metrics for organization: ${orgId}`);
+    if (!inboxSeries || !inboxTimeComparison || !orgId || !dateRange) {
+      return {
+        sessionInitialized: { current: 0, previous: 0, change: 0 },
+        updatePreferences: { current: 0, previous: 0, change: 0 },
+        markNotification: { current: 0, previous: 0, change: 0 },
+        updateAction: { current: 0, previous: 0, change: 0 },
+      };
+    }
+
+    Logger.debug(`Calculating inbox metrics for organization`);
     const getMetricStats = (
-      currentSeriesData: ISeriesData | undefined,
-      previousSeriesData: ISeriesData | undefined
+      currentSeriesData: IChannelData | undefined,
+      previousSeriesData: IChannelData | undefined
     ): IMetricStats => {
       if (!currentSeriesData || !previousSeriesData) {
         Logger.debug(`No series data available for ${orgId}`);
@@ -80,9 +90,6 @@ export class MetricsCalculatorService {
       const currentData = currentOrgData[this.roundToStartOfDay(dateRange.to_date)];
       const previousData = previousOrgData[this.roundToStartOfDay(dateRange.from_date)];
 
-      console.log(currentOrgData, 'HIII', this.roundToStartOfDay(dateRange.to_date));
-      console.log(previousOrgData, 'HIII', this.roundToStartOfDay(dateRange.from_date));
-
       if (!currentData || !previousData) {
         Logger.debug(`No data available for ${orgId}`);
 
@@ -100,28 +107,28 @@ export class MetricsCalculatorService {
 
     return {
       sessionInitialized: getMetricStats(
-        inboxSeries[MixpanelSeriesNameEnum.INBOX_SESSION_INITIALIZED],
-        inboxTimeComparison[MixpanelSeriesNameEnum.INBOX_SESSION_INITIALIZED]
+        inboxSeries[MixpanelInboxSeriesNameEnum.INBOX_SESSION_INITIALIZED],
+        inboxTimeComparison[MixpanelInboxSeriesNameEnum.INBOX_SESSION_INITIALIZED]
       ),
       updatePreferences: getMetricStats(
-        inboxSeries[MixpanelSeriesNameEnum.INBOX_UPDATE_PREFERENCES],
-        inboxTimeComparison[MixpanelSeriesNameEnum.INBOX_UPDATE_PREFERENCES]
+        inboxSeries[MixpanelInboxSeriesNameEnum.INBOX_UPDATE_PREFERENCES],
+        inboxTimeComparison[MixpanelInboxSeriesNameEnum.INBOX_UPDATE_PREFERENCES]
       ),
       markNotification: getMetricStats(
-        inboxSeries[MixpanelSeriesNameEnum.INBOX_MARK_NOTIFICATION],
-        inboxTimeComparison[MixpanelSeriesNameEnum.INBOX_MARK_NOTIFICATION]
+        inboxSeries[MixpanelInboxSeriesNameEnum.INBOX_MARK_NOTIFICATION],
+        inboxTimeComparison[MixpanelInboxSeriesNameEnum.INBOX_MARK_NOTIFICATION]
       ),
       updateAction: getMetricStats(
-        inboxSeries[MixpanelSeriesNameEnum.INBOX_UPDATE_ACTION],
-        inboxTimeComparison[MixpanelSeriesNameEnum.INBOX_UPDATE_ACTION]
+        inboxSeries[MixpanelInboxSeriesNameEnum.INBOX_UPDATE_ACTION],
+        inboxTimeComparison[MixpanelInboxSeriesNameEnum.INBOX_UPDATE_ACTION]
       ),
     };
   }
 
   calculateOverallInboxMetrics(
     orgId: string,
-    inboxSeries: IInboxResponse['series'],
-    inboxTimeComparison: IInboxResponse['time_comparison']['series']
+    inboxSeries: IMixpanelInboxResponse['series'],
+    inboxTimeComparison: IMixpanelInboxResponse['time_comparison']['series']
   ): IInboxMetrics {
     Logger.debug('Calculating overall inbox metrics');
 
@@ -142,94 +149,94 @@ export class MetricsCalculatorService {
 
     return {
       sessionInitialized: getMetricStats(
-        inboxSeries[MixpanelSeriesNameEnum.INBOX_SESSION_INITIALIZED][orgId],
-        inboxTimeComparison[MixpanelSeriesNameEnum.INBOX_SESSION_INITIALIZED][orgId]
+        inboxSeries[MixpanelInboxSeriesNameEnum.INBOX_SESSION_INITIALIZED][orgId],
+        inboxTimeComparison[MixpanelInboxSeriesNameEnum.INBOX_SESSION_INITIALIZED][orgId]
       ),
       updatePreferences: getMetricStats(
-        inboxSeries[MixpanelSeriesNameEnum.INBOX_UPDATE_PREFERENCES][orgId],
-        inboxTimeComparison[MixpanelSeriesNameEnum.INBOX_UPDATE_PREFERENCES][orgId]
+        inboxSeries[MixpanelInboxSeriesNameEnum.INBOX_UPDATE_PREFERENCES][orgId],
+        inboxTimeComparison[MixpanelInboxSeriesNameEnum.INBOX_UPDATE_PREFERENCES][orgId]
       ),
       markNotification: getMetricStats(
-        inboxSeries[MixpanelSeriesNameEnum.INBOX_MARK_NOTIFICATION][orgId],
-        inboxTimeComparison[MixpanelSeriesNameEnum.INBOX_MARK_NOTIFICATION][orgId]
+        inboxSeries[MixpanelInboxSeriesNameEnum.INBOX_MARK_NOTIFICATION][orgId],
+        inboxTimeComparison[MixpanelInboxSeriesNameEnum.INBOX_MARK_NOTIFICATION][orgId]
       ),
       updateAction: getMetricStats(
-        inboxSeries[MixpanelSeriesNameEnum.INBOX_UPDATE_ACTION][orgId],
-        inboxTimeComparison[MixpanelSeriesNameEnum.INBOX_UPDATE_ACTION][orgId]
+        inboxSeries[MixpanelInboxSeriesNameEnum.INBOX_UPDATE_ACTION][orgId],
+        inboxTimeComparison[MixpanelInboxSeriesNameEnum.INBOX_UPDATE_ACTION][orgId]
       ),
     };
   }
 
-  createOrganizationMetrics(
-    orgId: string,
-    subscriberSeries: ISeriesData,
-    subscriberTimeComparison: ISeriesData,
-    workflowSeries: ISeriesData,
-    workflowTimeComparison: ISeriesData
-  ): IOrganizationMetrics {
-    Logger.debug(`Creating organization metrics for: ${orgId}`);
-
-    const orgMetrics: IOrganizationMetrics = {
-      id: orgId,
-      name: '',
-      subscriberNotifications: {
-        current: Number(Object.values(subscriberSeries[orgId]?.$overall || {})[0] || 0),
-        previous: Number(Object.values(subscriberTimeComparison[orgId]?.$overall || {})[0] || 0),
-        change: 0,
-      },
-      channelBreakdown: {},
+  calculateEventTriggersMetrics(
+    subscriberSeries: IChannelData,
+    subscriberTimeComparison: IChannelData
+  ): IOrganizationMetrics['eventTriggers'] {
+    const current = Number(Object.values(subscriberSeries?.$overall || {})[0] || 0);
+    const previous = Number(Object.values(subscriberTimeComparison?.$overall || {})[0] || 0);
+    const change = this.calculateChange(current, previous);
+
+    return { current, previous, change };
+  }
+
+  calculateChannelBreakdown(
+    workflowSeries: IChannelData,
+    workflowTimeComparison: IChannelData
+  ): IOrganizationMetrics['channelBreakdown'] {
+    const channelBreakdown: IOrganizationMetrics['channelBreakdown'] = {
+      [ChannelTypeEnum.EMAIL]: { current: 0, previous: 0, change: 0 },
+      [ChannelTypeEnum.SMS]: { current: 0, previous: 0, change: 0 },
+      [ChannelTypeEnum.PUSH]: { current: 0, previous: 0, change: 0 },
+      [ChannelTypeEnum.IN_APP]: { current: 0, previous: 0, change: 0 },
+      [ChannelTypeEnum.CHAT]: { current: 0, previous: 0, change: 0 },
     };
 
-    Logger.debug(`Subscriber notifications for ${orgId}:`, orgMetrics.subscriberNotifications);
+    const orgWorkflowData = workflowSeries;
+    const orgWorkflowPreviousData = workflowTimeComparison;
 
-    const orgWorkflowData = workflowSeries[orgId];
-    const orgWorkflowPreviousData = workflowTimeComparison[orgId];
     if (orgWorkflowData && orgWorkflowPreviousData) {
       Object.entries(orgWorkflowData).forEach(([channel, data]) => {
         if (channel !== '$overall') {
-          const current = Number(Object.values(data.$overall || {})[0] || 0);
-          const previous = Number(Object.values(orgWorkflowPreviousData[channel]?.$overall || {})[0] || 0);
-
-          orgMetrics.channelBreakdown[channel] = {
-            current,
-            previous,
-            change: 0,
+          const currentChannelData = Number(Object.values(data.$overall || {})[0] || 0);
+          const previousChannelData = Number(Object.values(orgWorkflowPreviousData[channel]?.$overall || {})[0] || 0);
+          const currentChannelChange = this.calculateChange(currentChannelData, previousChannelData);
+
+          channelBreakdown[channel] = {
+            current: currentChannelData,
+            previous: previousChannelData,
+            change: currentChannelChange,
           };
-
-          Logger.debug(`Channel metrics for ${orgId}/${channel}: current=${current}, previous=${previous}`);
         }
       });
     } else {
-      Logger.debug(`No workflow data available for organization: ${orgId}`);
+      Logger.debug(`No workflow data available for organization`);
     }
 
-    return orgMetrics;
+    return channelBreakdown;
   }
 
   calculateWorkflowStats(
-    orgId: string,
-    subscriberSeries: ISeriesData,
-    subscriberTimeComparison: ISeriesData
-  ): IMixpanelResponse['workflowStats'] {
+    triggerEventSeries: IChannelData,
+    previousTriggerEventSeries: IChannelData
+  ): IMixpanelTriggerResponse['workflowStats']['workflows'] {
     Logger.debug('Calculating workflow statistics');
-    const workflowStats: IMixpanelResponse['workflowStats'] = { workflows: {} };
+    const workflowStats: IMixpanelTriggerResponse['workflowStats']['workflows'] = {};
 
-    const orgData = subscriberSeries[orgId]?.undefined;
-    const orgPreviousData = subscriberTimeComparison[orgId]?.undefined;
-    if (!orgData || !orgPreviousData) {
-      Logger.debug(`No workflow data found for organization: ${orgId}`);
+    const currentWorkflowsData = triggerEventSeries.undefined;
+    const previousWorkflowsData = previousTriggerEventSeries.undefined;
+    if (!currentWorkflowsData || !previousWorkflowsData) {
+      Logger.debug(`No workflow data found for organization`);
 
       return workflowStats;
     }
 
-    Object.entries(orgData)
+    Object.entries(currentWorkflowsData)
       .filter(([name]) => name !== '$overall')
       .forEach(([name, data]) => {
         const current = Number(Object.values(data)[0] || 0);
-        const previous = Number(Object.values(orgPreviousData[name] || {})[0] || 0);
+        const previous = Number(Object.values(previousWorkflowsData[name] || {})[0] || 0);
         const change = this.calculateChange(current, previous);
 
-        workflowStats.workflows[name] = { current, previous, change };
+        workflowStats[name] = { current, previous, change };
         Logger.debug(`Workflow stats for ${name}: current=${current}, previous=${previous}, change=${change}%`);
       });
 

diff --git a/apps/api/src/app/insights/services/mixpanel.service.ts b/apps/api/src/app/insights/services/mixpanel.service.ts
@@ -2,7 +2,7 @@ import { Injectable, Logger } from '@nestjs/common';
 import axios from 'axios';
 import { promises as fs } from 'fs';
 import { join } from 'path';
-import { IMixpanelResponse, IInboxResponse } from '../usecases/usage-insights/types/usage-insights.types';
+import { IMixpanelInboxResponse, IMixpanelTriggerResponse } from '../types/usage-insights.types';
 
 const USE_INSIGHTS_CACHE = process.env.USE_INSIGHTS_CACHE === 'true';
 
@@ -61,7 +61,7 @@ export class MixpanelService {
     }
   }
 
-  async fetchMixpanelInsights(): Promise<IMixpanelResponse | null> {
+  async fetchMixpanelInsights(): Promise<IMixpanelTriggerResponse | null> {
     Logger.debug('Fetching Mixpanel insights');
     const cachedData = await this.readCacheFile(this.CACHE_FILE);
     if (cachedData) {
@@ -70,7 +70,7 @@ export class MixpanelService {
 
     try {
       Logger.debug('Making Mixpanel API request for insights');
-      const response = await axios.get<IMixpanelResponse>('https://mixpanel.com/api/2.0/insights', {
+      const response = await axios.get<IMixpanelTriggerResponse>('https://mixpanel.com/api/2.0/insights', {
         params: {
           project_id: '2667883',
           bookmark_id: '68515975',
@@ -92,7 +92,7 @@ export class MixpanelService {
     }
   }
 
-  async fetchInboxInsights(): Promise<IInboxResponse | null> {
+  async fetchInboxInsights(): Promise<IMixpanelInboxResponse | null> {
     Logger.debug('Fetching Inbox insights');
     const cachedData = await this.readCacheFile(this.INBOX_CACHE_FILE);
     if (cachedData) {
@@ -102,7 +102,7 @@ export class MixpanelService {
     try {
       Logger.debug('Making Mixpanel API request for inbox insights');
 
-      const response = await axios.get<IInboxResponse>('https://mixpanel.com/api/2.0/insights', {
+      const response = await axios.get<IMixpanelInboxResponse>('https://mixpanel.com/api/2.0/insights', {
         params: {
           project_id: '2667883',
           bookmark_id: '68521376',

diff --git a/apps/api/src/app/insights/services/organization-notification.service.ts b/apps/api/src/app/insights/services/organization-notification.service.ts
@@ -3,8 +3,7 @@ import { CommunityOrganizationRepository } from '@novu/dal';
 import { FeatureFlagsService } from '@novu/application-generic';
 import { FeatureFlagsKeysEnum } from '@novu/shared';
 import { usageInsightsWorkflow } from '@novu/notifications';
-
-import { IDateRange, ICombinedMetrics, IMixpanelResponse } from '../usecases/usage-insights/types/usage-insights.types';
+import { IDateRange, IOrganizationMetrics } from '../types/usage-insights.types';
 
 @Injectable()
 export class OrganizationNotificationService {
@@ -13,28 +12,18 @@ export class OrganizationNotificationService {
     private featureFlagsService: FeatureFlagsService
   ) {}
 
-  async sendOrganizationNotification(
-    metrics: ICombinedMetrics,
-    workflowStats: IMixpanelResponse['workflowStats'],
-    dateRange: IDateRange
-  ) {
-    Logger.debug(`Processing metrics for organization: ${metrics.id}`);
+  async sendOrganizationNotification(organizationId: string, metrics: IOrganizationMetrics, dateRange: IDateRange) {
+    Logger.debug(`Processing metrics for organization: ${organizationId}`);
     try {
       const organization = await this.organizationRepository.findById('675fe9bcab6a05bb6dcb7dab');
 
       if (!organization) {
-        Logger.warn(`Organization not found in repository: ${metrics.id}`);
+        Logger.warn(`Organization not found in repository: ${organizationId}`);
 
         return;
       }
 
-      const enrichedMetrics = {
-        ...metrics,
-        name: organization.name,
-        workflowStats: workflowStats.workflows,
-      };
-
-      Logger.debug(`Enriched metrics for ${organization.name}:`, enrichedMetrics);
+      Logger.debug(`Enriched metrics for ${organization.name}:`, metrics);
 
       const isEnabled = await this.featureFlagsService.get(FeatureFlagsKeysEnum.IS_USAGE_INSIGHTS_ENABLED, false, {
         environmentId: 'system',
@@ -43,42 +32,37 @@ export class OrganizationNotificationService {
       });
 
       if (!isEnabled) {
-        Logger.log('Skipping notification delivery - usage insights disabled by feature flag', enrichedMetrics);
+        Logger.log('Skipping notification delivery - usage insights disabled by feature flag', metrics);
 
         return;
       }
 
+      const payload = {
+        organizationName: organization.name,
+        period: {
+          current: dateRange.to_date,
+          previous: dateRange.from_date,
+        },
+        subscriberNotifications: metrics.eventTriggers,
+        channelBreakdown: metrics.channelBreakdown,
+        inboxMetrics: metrics.inboxMetrics,
+        workflowStats: metrics.workflowStats,
+      };
+
+      delete (payload.channelBreakdown as any).trigger;
+
+      Logger.debug(`Sending notification for ${organization.name} with payload:`, payload);
+
       await usageInsightsWorkflow.trigger({
         to: {
           subscriberId: '675fe9bcab6a05bb6dcb7dab_11',
           email: `dima+testing-${organization._id}@novu.co`,
         },
-        payload: {
-          organizationName: organization.name,
-          period: {
-            current: dateRange.to_date,
-            previous: dateRange.from_date,
-          },
-          subscriberNotifications: metrics.subscriberNotifications,
-          channelBreakdown: {
-            email: metrics.channelBreakdown.email || { current: 0, previous: 0, change: 0 },
-            sms: metrics.channelBreakdown.sms || { current: 0, previous: 0, change: 0 },
-            push: metrics.channelBreakdown.push || { current: 0, previous: 0, change: 0 },
-            inApp: metrics.channelBreakdown.in_app || { current: 0, previous: 0, change: 0 },
-            chat: metrics.channelBreakdown.chat || { current: 0, previous: 0, change: 0 },
-          },
-          inboxMetrics: {
-            sessionInitialized: metrics.inboxMetrics?.sessionInitialized,
-            updatePreferences: metrics.inboxMetrics?.updatePreferences,
-            markNotification: metrics.inboxMetrics?.markNotification,
-            updateAction: metrics.inboxMetrics?.updateAction,
-          },
-          workflowStats: workflowStats.workflows,
-        },
+        payload,
         secretKey: process.env.NOVU_INTERNAL_SECRET_KEY,
       });
     } catch (error) {
-      Logger.error(`Failed to process metrics for organization ${metrics.id}:`, error);
+      Logger.error(`Failed to process metrics for organization ${organizationId}:`, error);
     }
   }
 }