fix: base test

Author: scopsy

apps/api/src/app/webhooks/dtos/webhook-payload.dto.ts

@@ -1,13 +1,13 @@
 import { ApiProperty } from '@nestjs/swagger';
 import { WorkflowResponseDto } from '../../workflows-v2/dtos/workflow-response.dto';
 
-enum WebhookEventEnum {
+export enum WebhookEventEnum {
   WORKFLOW_CREATED = 'workflow.created',
   WORKFLOW_UPDATED = 'workflow.updated',
   WORKFLOW_DELETED = 'workflow.deleted',
 }
 
-enum WebhookObjectTypeEnum {
+export enum WebhookObjectTypeEnum {
   WORKFLOW = 'workflow',
 }
 

apps/api/src/app/webhooks/usecases/send-webhook-message/send-webhook-message.command.ts

@@ -0,0 +1,25 @@
+import { IsDefined, IsString, IsEnum, ValidateNested } from 'class-validator';
+import { Type } from 'class-transformer';
+import { BaseCommand } from '@novu/application-generic';
+
+import { WorkflowResponseDto } from '../../../workflows-v2/dtos/workflow-response.dto'; // Corrected path
+import { WebhookEventEnum, WebhookObjectTypeEnum } from '../../dtos/webhook-payload.dto';
+import { EnvironmentCommand } from '../../../shared/commands/project.command';
+
+export class SendWebhookMessageCommand extends EnvironmentCommand {
+  @IsEnum(WebhookEventEnum)
+  eventType: WebhookEventEnum;
+
+  @IsDefined()
+  @IsEnum(WebhookObjectTypeEnum)
+  objectType: WebhookObjectTypeEnum;
+
+  /*
+   * Assuming the payload data structure matches WorkflowResponseDto for now
+   * This might need to be made more generic if other object types are introduced
+   */
+  @IsDefined()
+  @ValidateNested()
+  @Type(() => WorkflowResponseDto)
+  payload: WorkflowResponseDto;
+}

apps/api/src/app/webhooks/usecases/send-webhook-message/send-webhook-message.usecase.ts

@@ -0,0 +1,62 @@
+import { Inject, Injectable, Logger, Scope } from '@nestjs/common';
+import { Svix } from 'svix';
+import { v4 as uuidv4 } from 'uuid';
+
+import { SendWebhookMessageCommand } from './send-webhook-message.command';
+import { WrapperDto } from '../../dtos/webhook-payload.dto';
+
+const LOG_CONTEXT = 'SendWebhookMessageUseCase';
+
+@Injectable({
+  scope: Scope.REQUEST, // Assuming command context might be needed later
+})
+export class SendWebhookMessage {
+  constructor(@Inject('SVIX_CLIENT') private svix: Svix) {}
+
+  async execute(command: SendWebhookMessageCommand): Promise<{ eventId: string } | undefined> {
+    const eventId = `evt_${uuidv4().replace(/-/g, '')}`;
+
+    const webhookPayload: WrapperDto<any> = {
+      type: command.eventType,
+      object: command.objectType,
+      data: command.payload,
+      timestamp: new Date().toISOString(),
+      environmentId: command.environmentId,
+    };
+
+    console.log('webhookPayload', webhookPayload);
+
+    try {
+      Logger.log(
+        `Attempting to send webhook ${command.eventType} for application ${command.organizationId}-${command.environmentId}, Event ID: ${eventId}`,
+        LOG_CONTEXT
+      );
+
+      const message = await this.svix.message.create(`${command.organizationId}-${command.environmentId}`, {
+        eventType: command.eventType,
+        eventId,
+        payload: webhookPayload,
+      });
+
+      Logger.log(
+        `Successfully sent webhook ${command.eventType}. Svix Message ID: ${message.id}, Event ID: ${eventId}`,
+        LOG_CONTEXT
+      );
+
+      return { eventId };
+    } catch (error: any) {
+      Logger.error(
+        `Failed to send webhook ${command.eventType} for application ${
+          command.applicationId
+        }. Error: ${error.message}, Event ID: ${eventId}`,
+        error.stack,
+        LOG_CONTEXT
+      );
+      /*
+       * Depending on requirements, you might want to throw the error,
+       * return a specific error object, or handle it differently.
+       */
+      throw error;
+    }
+  }
+}

apps/api/src/app/webhooks/webhooks.module.ts

@@ -3,6 +3,7 @@ import { Svix } from 'svix'; // Import Svix SDK
 import { SharedModule } from '../shared/shared.module';
 import { WebhooksController } from './webhooks.controller';
 import { GetWebhookPortalTokenUsecase } from './usecases/get-webhook-portal-token/get-webhook-portal-token.usecase';
+import { SendWebhookMessage } from './usecases/send-webhook-message/send-webhook-message.usecase';
 
 // Define the custom provider for the Svix client
 const svixProvider: Provider = {
@@ -20,10 +21,7 @@ const svixProvider: Provider = {
 @Module({
   imports: [SharedModule],
   controllers: [WebhooksController],
-  providers: [
-    GetWebhookPortalTokenUsecase,
-    svixProvider, // Add the Svix client provider
-  ],
-  exports: [],
+  providers: [GetWebhookPortalTokenUsecase, svixProvider, SendWebhookMessage],
+  exports: [SendWebhookMessage],
 })
 export class WebhooksModule {}

apps/api/src/app/workflows-v2/usecases/patch-workflow/patch-workflow.usecase.ts

@@ -2,27 +2,40 @@ import { Injectable } from '@nestjs/common';
 import { UserSessionData, WorkflowStatusEnum } from '@novu/shared';
 import { NotificationTemplateEntity, NotificationTemplateRepository } from '@novu/dal';
 import { GetWorkflowWithPreferencesUseCase, WorkflowWithPreferencesResponseDto } from '@novu/application-generic';
+import { SendWebhookMessage } from '../../../webhooks/usecases/send-webhook-message/send-webhook-message.usecase';
 import { PatchWorkflowCommand } from './patch-workflow.command';
 import { GetWorkflowUseCase } from '../get-workflow';
 import { WorkflowResponseDto } from '../../dtos';
+import { WebhookEventEnum, WebhookObjectTypeEnum } from '../../../webhooks/dtos/webhook-payload.dto';
 
 @Injectable()
 export class PatchWorkflowUsecase {
   constructor(
     private getWorkflowWithPreferencesUseCase: GetWorkflowWithPreferencesUseCase,
     private notificationTemplateRepository: NotificationTemplateRepository,
-    private getWorkflowUseCase: GetWorkflowUseCase
+    private getWorkflowUseCase: GetWorkflowUseCase,
+    private sendWebhookMessage: SendWebhookMessage
   ) {}
 
   async execute(command: PatchWorkflowCommand): Promise<WorkflowResponseDto> {
     const persistedWorkflow = await this.fetchWorkflow(command);
     const transientWorkflow = this.patchWorkflowFields(persistedWorkflow, command);
     await this.persistWorkflow(transientWorkflow, command.user);
 
-    return await this.getWorkflowUseCase.execute({
+    const updatedWorkflow = await this.getWorkflowUseCase.execute({
       workflowIdOrInternalId: command.workflowIdOrInternalId,
       user: command.user,
     });
+
+    await this.sendWebhookMessage.execute({
+      eventType: WebhookEventEnum.WORKFLOW_UPDATED,
+      objectType: WebhookObjectTypeEnum.WORKFLOW,
+      payload: updatedWorkflow,
+      organizationId: command.user.organizationId,
+      environmentId: command.user.environmentId,
+    });
+
+    return updatedWorkflow;
   }
 
   private patchWorkflowFields(

apps/api/src/app/workflows-v2/usecases/upsert-workflow/upsert-workflow.usecase.ts

@@ -37,6 +37,8 @@ import { BuildStepIssuesUsecase } from '../build-step-issues/build-step-issues.u
 import { GetWorkflowCommand, GetWorkflowUseCase } from '../get-workflow';
 import { UpsertStepDataCommand, UpsertWorkflowCommand } from './upsert-workflow.command';
 import { StepIssuesDto, WorkflowResponseDto } from '../../dtos';
+import { SendWebhookMessage } from '../../../webhooks/usecases/send-webhook-message/send-webhook-message.usecase';
+import { WebhookEventEnum, WebhookObjectTypeEnum } from '../../../webhooks/dtos/webhook-payload.dto';
 
 @Injectable()
 export class UpsertWorkflowUseCase {
@@ -49,7 +51,8 @@ export class UpsertWorkflowUseCase {
     private buildStepIssuesUsecase: BuildStepIssuesUsecase,
     private controlValuesRepository: ControlValuesRepository,
     private upsertControlValuesUseCase: UpsertControlValuesUseCase,
-    private analyticsService: AnalyticsService
+    private analyticsService: AnalyticsService,
+    private sendWebhookMessage: SendWebhookMessage
   ) {}
 
   @InstrumentUsecase()
@@ -84,12 +87,22 @@ export class UpsertWorkflowUseCase {
 
     await this.upsertControlValues(upsertedWorkflow, command);
 
-    return await this.getWorkflowUseCase.execute(
+    const updatedWorkflow = await this.getWorkflowUseCase.execute(
       GetWorkflowCommand.create({
         workflowIdOrInternalId: upsertedWorkflow._id,
         user: command.user,
       })
     );
+
+    await this.sendWebhookMessage.execute({
+      eventType: WebhookEventEnum.WORKFLOW_UPDATED,
+      objectType: WebhookObjectTypeEnum.WORKFLOW,
+      payload: updatedWorkflow,
+      organizationId: command.user.organizationId,
+      environmentId: command.user.environmentId,
+    });
+
+    return updatedWorkflow;
   }
 
   private async buildCreateWorkflowCommand(command: UpsertWorkflowCommand): Promise<CreateWorkflowCommand> {

apps/api/src/app/workflows-v2/workflow.module.ts

@@ -35,11 +35,20 @@ import { CreateVariablesObject } from './usecases/create-variables-object/create
 import { BuildStepIssuesUsecase } from './usecases/build-step-issues/build-step-issues.usecase';
 import { WorkflowController } from './workflow.controller';
 import { DuplicateWorkflowUseCase } from './usecases/duplicate-workflow/duplicate-workflow.usecase';
+import { WebhooksModule } from '../webhooks/webhooks.module';
 
 const DAL_REPOSITORIES = [CommunityOrganizationRepository];
 
 @Module({
-  imports: [SharedModule, MessageTemplateModule, ChangeModule, AuthModule, BridgeModule, IntegrationModule],
+  imports: [
+    SharedModule,
+    MessageTemplateModule,
+    ChangeModule,
+    AuthModule,
+    BridgeModule,
+    IntegrationModule,
+    WebhooksModule,
+  ],
   controllers: [WorkflowController],
   providers: [
     ...DAL_REPOSITORIES,