Merge branch 'next' into provider-integrations-limits

Author: scopsy

apps/api/src/app/inbox/dtos/subscriber-session-response.dto.ts

@@ -2,6 +2,6 @@ export class SubscriberSessionResponseDto {
   readonly token: string;
   readonly totalUnreadCount: number;
   readonly removeNovuBranding: boolean;
-  readonly isSnoozeEnabled: boolean;
+  readonly maxSnoozeDurationHours: number;
   readonly isDevelopmentMode: boolean;
 }

apps/api/src/app/inbox/usecases/session/session.spec.ts

@@ -2,12 +2,7 @@ import sinon from 'sinon';
 import { expect } from 'chai';
 import { NotFoundException, BadRequestException } from '@nestjs/common';
 import { CommunityOrganizationRepository, EnvironmentRepository, IntegrationRepository } from '@novu/dal';
-import {
-  AnalyticsService,
-  CreateOrUpdateSubscriberUseCase,
-  FeatureFlagsService,
-  SelectIntegration,
-} from '@novu/application-generic';
+import { AnalyticsService, CreateOrUpdateSubscriberUseCase, SelectIntegration } from '@novu/application-generic';
 import { ApiServiceLevelEnum, ChannelTypeEnum, InAppProviderIdEnum } from '@novu/shared';
 import { AuthService } from '../../../auth/services/auth.service';
 import { Session } from './session.usecase';
@@ -45,7 +40,6 @@ describe('Session', () => {
   let notificationsCount: sinon.SinonStubbedInstance<NotificationsCount>;
   let integrationRepository: sinon.SinonStubbedInstance<IntegrationRepository>;
   let organizationRepository: sinon.SinonStubbedInstance<CommunityOrganizationRepository>;
-  let featureFlagsService: sinon.SinonStubbedInstance<FeatureFlagsService>;
 
   beforeEach(() => {
     environmentRepository = sinon.createStubInstance(EnvironmentRepository);
@@ -56,7 +50,6 @@ describe('Session', () => {
     notificationsCount = sinon.createStubInstance(NotificationsCount);
     integrationRepository = sinon.createStubInstance(IntegrationRepository);
     organizationRepository = sinon.createStubInstance(CommunityOrganizationRepository);
-    featureFlagsService = sinon.createStubInstance(FeatureFlagsService);
 
     session = new Session(
       environmentRepository as any,
@@ -66,8 +59,7 @@ describe('Session', () => {
       analyticsService as any,
       notificationsCount as any,
       integrationRepository as any,
-      organizationRepository as any,
-      featureFlagsService as any
+      organizationRepository as any
     );
   });
 
@@ -226,9 +218,7 @@ describe('Session', () => {
     ).to.be.true;
   });
 
-  it('should return the correct isSnoozeEnabled value for different service levels', async () => {
-    featureFlagsService.getFlag.resolves(true);
-
+  it('should return the correct maxSnoozeDurationHours value for different service levels', async () => {
     const command: SessionCommand = {
       applicationIdentifier: 'app-id',
       subscriber: { subscriberId: 'subscriber-id' },
@@ -247,24 +237,24 @@ describe('Session', () => {
     notificationsCount.execute.resolves(notificationCount);
     authService.getSubscriberWidgetToken.resolves(token);
 
-    // FREE plan should have snooze disabled
+    // FREE plan should have 24 hours max snooze duration
     organizationRepository.findOne.resolves({ apiServiceLevel: ApiServiceLevelEnum.FREE } as any);
     const freeResponse: SubscriberSessionResponseDto = await session.execute(command);
-    expect(freeResponse.isSnoozeEnabled).to.equal(false);
+    expect(freeResponse.maxSnoozeDurationHours).to.equal(24);
 
-    // PRO plan should have snooze enabled
+    // PRO plan should have 90 days max snooze duration
     organizationRepository.findOne.resolves({ apiServiceLevel: ApiServiceLevelEnum.PRO } as any);
     const proResponse: SubscriberSessionResponseDto = await session.execute(command);
-    expect(proResponse.isSnoozeEnabled).to.equal(true);
+    expect(proResponse.maxSnoozeDurationHours).to.equal(90 * 24);
 
-    // BUSINESS/TEAM plan should have snooze enabled
+    // BUSINESS/TEAM plan should have 90 days max snooze duration
     organizationRepository.findOne.resolves({ apiServiceLevel: ApiServiceLevelEnum.BUSINESS } as any);
     const businessResponse: SubscriberSessionResponseDto = await session.execute(command);
-    expect(businessResponse.isSnoozeEnabled).to.equal(true);
+    expect(businessResponse.maxSnoozeDurationHours).to.equal(90 * 24);
 
-    // ENTERPRISE plan should have snooze enabled
+    // ENTERPRISE plan should have 90 days max snooze duration
     organizationRepository.findOne.resolves({ apiServiceLevel: ApiServiceLevelEnum.ENTERPRISE } as any);
     const enterpriseResponse: SubscriberSessionResponseDto = await session.execute(command);
-    expect(enterpriseResponse.isSnoozeEnabled).to.equal(true);
+    expect(enterpriseResponse.maxSnoozeDurationHours).to.equal(90 * 24);
   });
 });

apps/api/src/app/inbox/usecases/session/session.usecase.ts

@@ -6,20 +6,16 @@ import {
   LogDecorator,
   SelectIntegration,
   SelectIntegrationCommand,
-  FeatureFlagsService,
 } from '@novu/application-generic';
 import {
   CommunityOrganizationRepository,
   EnvironmentEntity,
   EnvironmentRepository,
   IntegrationRepository,
-  OrganizationEntity,
-  UserEntity,
 } from '@novu/dal';
 import {
   ApiServiceLevelEnum,
   ChannelTypeEnum,
-  FeatureFlagsKeysEnum,
   FeatureNameEnum,
   getFeatureForTierAsNumber,
   InAppProviderIdEnum,
@@ -46,8 +42,7 @@ export class Session {
     private analyticsService: AnalyticsService,
     private notificationsCount: NotificationsCount,
     private integrationRepository: IntegrationRepository,
-    private organizationRepository: CommunityOrganizationRepository,
-    private featureFlagsService: FeatureFlagsService
+    private organizationRepository: CommunityOrganizationRepository
   ) {}
 
   @LogDecorator()
@@ -116,11 +111,7 @@ export class Session {
     const token = await this.authService.getSubscriberWidgetToken(subscriber);
 
     const removeNovuBranding = inAppIntegration.removeNovuBranding || false;
-    const isSnoozeEnabled = await this.isSnoozeEnabled(
-      environment._organizationId,
-      environment._id,
-      command.subscriber.subscriberId
-    );
+    const maxSnoozeDurationHours = await this.getMaxSnoozeDurationHours(environment);
 
     /**
      * We want to prevent the playground inbox demo from marking the integration as connected
@@ -151,34 +142,22 @@ export class Session {
       token,
       totalUnreadCount,
       removeNovuBranding,
-      isSnoozeEnabled,
+      maxSnoozeDurationHours,
       isDevelopmentMode: environment.name.toLowerCase() !== 'production',
     };
   }
 
-  private async isSnoozeEnabled(organizationId: string, environmentId: string, subscriberId: string) {
+  private async getMaxSnoozeDurationHours(environment: EnvironmentEntity) {
     const organization = await this.organizationRepository.findOne({
-      _id: organizationId,
-    });
-
-    const isSnoozeEnabled = await this.featureFlagsService.getFlag({
-      key: FeatureFlagsKeysEnum.IS_SNOOZE_ENABLED,
-      defaultValue: false,
-      organization: { _id: organizationId } as OrganizationEntity,
-      environment: { _id: environmentId } as EnvironmentEntity,
-      user: { _id: subscriberId } as UserEntity,
+      _id: environment._organizationId,
     });
 
-    if (!isSnoozeEnabled) {
-      return false;
-    }
-
     const tierLimitMs = getFeatureForTierAsNumber(
       FeatureNameEnum.PLATFORM_MAX_SNOOZE_DURATION,
       organization?.apiServiceLevel || ApiServiceLevelEnum.FREE,
       true
     );
 
-    return tierLimitMs > 0;
+    return tierLimitMs / 1000 / 60 / 60;
   }
 }

apps/api/src/app/inbox/usecases/snooze-notification/snooze-notification.usecase.ts

@@ -12,7 +12,6 @@ import {
   DetailEnum,
   StandardQueueService,
   FeatureFlagsService,
-  SYSTEM_LIMITS,
   PinoLogger,
 } from '@novu/application-generic';
 import {
@@ -57,20 +56,18 @@ export class SnoozeNotification {
   ) {}
 
   public async execute(command: SnoozeNotificationCommand): Promise<InboxNotification> {
-    await this.isSnoozeEnabled(command);
-
-    const delayAmountMs = this.calculateDelayInMs(command.snoozeUntil);
-    await this.validateDelayDuration(command, delayAmountMs);
+    const snoozeDurationMs = this.calculateDelayInMs(command.snoozeUntil);
+    await this.validateSnoozeDuration(command, snoozeDurationMs);
     const notification = await this.findNotification(command);
 
     try {
       let scheduledJob = {} as JobEntity;
       let snoozedNotification = {} as InboxNotification;
 
       await this.messageRepository.withTransaction(async () => {
-        scheduledJob = await this.createScheduledUnsnoozeJob(notification, delayAmountMs);
+        scheduledJob = await this.createScheduledUnsnoozeJob(notification, snoozeDurationMs);
         snoozedNotification = await this.markNotificationAsSnoozed(command);
-        await this.enqueueJob(scheduledJob, delayAmountMs);
+        await this.enqueueJob(scheduledJob, snoozeDurationMs);
       });
 
       // fire and forget
@@ -113,7 +110,7 @@ export class SnoozeNotification {
     });
   }
 
-  private async isSnoozeEnabled(command: SnoozeNotificationCommand) {
+  private async validateSnoozeDuration(command: SnoozeNotificationCommand, snoozeDurationMs: number) {
     const isSnoozeEnabled = await this.featureFlagsService.getFlag({
       key: FeatureFlagsKeysEnum.IS_SNOOZE_ENABLED,
       defaultValue: false,
@@ -125,26 +122,16 @@ export class SnoozeNotification {
     if (!isSnoozeEnabled) {
       throw new NotImplementedException();
     }
-  }
-
-  private calculateDelayInMs(snoozeUntil: Date): number {
-    return snoozeUntil.getTime() - new Date().getTime();
-  }
 
-  private async validateDelayDuration(command: SnoozeNotificationCommand, delay: number) {
-    const tierLimit = await this.getTierLimit(command);
+    const organization = await this.getOrganization(command.organizationId);
 
-    if (tierLimit === 0) {
-      throw new HttpException(
-        {
-          message: 'Feature Not Available',
-          reason: 'Snooze functionality is not available on your current plan. Please upgrade to access this feature.',
-        },
-        HttpStatus.PAYMENT_REQUIRED
-      );
-    }
+    const tierLimitMs = getFeatureForTierAsNumber(
+      FeatureNameEnum.PLATFORM_MAX_SNOOZE_DURATION,
+      organization?.apiServiceLevel || ApiServiceLevelEnum.FREE,
+      true
+    );
 
-    if (delay > tierLimit) {
+    if (snoozeDurationMs > tierLimitMs) {
       throw new HttpException(
         {
           message: 'Snooze Duration Limit Exceeded',
@@ -157,34 +144,20 @@ export class SnoozeNotification {
     }
   }
 
-  private async getTierLimit(command: SnoozeNotificationCommand) {
-    const systemLimitMs = await this.featureFlagsService.getFlag({
-      key: FeatureFlagsKeysEnum.MAX_DEFER_DURATION_IN_MS_NUMBER,
-      defaultValue: SYSTEM_LIMITS.DEFER_DURATION_MS,
-      environment: { _id: command.environmentId },
-      organization: { _id: command.organizationId },
-    });
-
-    /**
-     * If the system limit is not the default, we need to use it as the limit
-     * for the specific customer exceptions from the tier limit
-     */
-    const isSpecialLimit = systemLimitMs !== SYSTEM_LIMITS.DEFER_DURATION_MS;
-    if (isSpecialLimit) {
-      return systemLimitMs;
-    }
+  private calculateDelayInMs(snoozeUntil: Date): number {
+    return snoozeUntil.getTime() - new Date().getTime();
+  }
 
+  private async getOrganization(organizationId: string): Promise<OrganizationEntity> {
     const organization = await this.organizationRepository.findOne({
-      _id: command.organizationId,
+      _id: organizationId,
     });
 
-    const tierLimitMs = getFeatureForTierAsNumber(
-      FeatureNameEnum.PLATFORM_MAX_SNOOZE_DURATION,
-      organization?.apiServiceLevel || ApiServiceLevelEnum.FREE,
-      true
-    );
+    if (!organization) {
+      throw new NotFoundException(`Organization id: '${organizationId}' not found`);
+    }
 
-    return Math.min(systemLimitMs, tierLimitMs);
+    return organization;
   }
 
   private async findNotification(command: SnoozeNotificationCommand): Promise<MessageEntity> {

apps/api/src/app/inbox/usecases/unsnooze-notification/unsnooze-notification.usecase.ts

@@ -71,7 +71,7 @@ export class UnsnoozeNotification {
         _environmentId: command.environmentId,
         delay: { $exists: true },
         status: JobStatusEnum.PENDING,
-        'payload.snooze': true,
+        'payload.unsnooze': true,
       });
 
       unsnoozedNotification = await this.markNotificationAs.execute(
@@ -103,7 +103,7 @@ export class UnsnoozeNotification {
         });
     } else {
       this.logger.error(
-        `Could not find a scheduled job for snoozed notification '${command.notificationId}'. ` +
+        `Could not find a scheduled job for snoozed notification '${notificationId}'. ` +
           'The notification may have already been unsnoozed or the scheduled job was deleted.'
       );
     }

apps/api/src/app/workflows-v2/e2e/generate-preview.e2e.ts

@@ -1500,6 +1500,47 @@ describe('Workflow Step Preview - POST /:workflowId/step/:stepId/preview #novu-v
       });
       expect(previewResponse4.result.result.preview.body).to.contain('hello');
       expect(previewResponse4.result.result.preview.body).to.contain('new');
+
+      const controlValues4 = {
+        body: `{"type":"doc","content":[{"type":"paragraph","attrs":{"textAlign":null,"showIfKey":null},"content":[{"type":"variable","attrs":{"id":"payload.items","label":null,"fallback":null,"required":false,"aliasFor":null}},{"type":"text","text":" "}]}]}`,
+        subject: 'events length',
+      };
+
+      const resultForPayloadItems = {
+        payload: {
+          items: 'items',
+        },
+      };
+
+      const previewResponse7 = await novuClient.workflows.steps.generatePreview({
+        generatePreviewRequestDto: {
+          controlValues: controlValues4,
+          previewPayload: {},
+        },
+        stepId: emailStepDatabaseId,
+        workflowId,
+      });
+      expect(previewResponse7.result.previewPayloadExample).to.deep.equal(resultForPayloadItems);
+
+      const editedItemsToArray = {
+        payload: {
+          items: [
+            {
+              name: 'name',
+            },
+          ],
+        },
+      };
+      const previewResponse8 = await novuClient.workflows.steps.generatePreview({
+        generatePreviewRequestDto: {
+          controlValues: controlValues4,
+          previewPayload: editedItemsToArray,
+        },
+        stepId: emailStepDatabaseId,
+        workflowId,
+      });
+
+      expect(previewResponse8.result.previewPayloadExample).to.deep.equal(editedItemsToArray);
     });
   });
 

apps/worker/src/app/workflow/usecases/process-unsnooze-job/process-unsnooze-job.usecase.ts

@@ -50,17 +50,28 @@ export class ProcessUnsnoozeJob {
         );
       }
 
+      const nowDate = new Date();
+      const createdAtDate = new Date(snoozedNotification.createdAt);
+
       await this.messageRepository.update(
         { _environmentId: job._environmentId, _notificationId: job._notificationId },
-        {
-          $set: {
-            snoozedUntil: null,
-            createdAt: new Date(),
-          },
-          $addToSet: {
-            deliveredAt: { $each: [snoozedNotification.createdAt, new Date()] },
+        [
+          {
+            $set: {
+              snoozedUntil: null,
+              createdAt: nowDate,
+              read: false,
+              lastReadDate: null,
+              deliveredAt: {
+                $cond: {
+                  if: { $isArray: '$deliveredAt' },
+                  then: { $concatArrays: ['$deliveredAt', [nowDate]] },
+                  else: [createdAtDate, nowDate],
+                },
+              },
+            },
           },
-        },
+        ],
         {
           timestamps: false,
           strict: false,