[PB-4258]: feat/jaas webhook

package.json

@@ -34,6 +34,7 @@
     "@nestjs/swagger": "^11.1.0",
     "agentkeepalive": "^4.6.0",
     "axios": "^1.8.4",
+    "body-parser": "^2.2.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
     "cross-env": "^7.0.3",

src/app.module.ts

@@ -7,6 +7,7 @@ import { SequelizeModule, SequelizeModuleOptions } from '@nestjs/sequelize';
 import { format } from 'sql-formatter';
 import { ReplicationOptions } from 'sequelize';
 import { UserModule } from './modules/user/user.module';
+import { WebhookModule } from './modules/webhook/webhook.module';
 
 const defaultDbConfig = (
   configService: ConfigService,
@@ -79,6 +80,7 @@ const defaultDbConfig = (
     }),
     CallModule,
     UserModule,
+    WebhookModule,
   ],
   controllers: [],
 })

src/config/configuration.ts

@@ -16,6 +16,13 @@ export default () => ({
     appId: process.env.JITSI_APP_ID,
     apiKey: process.env.JITSI_API_KEY,
   },
+  jitsiWebhook: {
+    secret: process.env.JITSI_WEBHOOK_SECRET,
+    events: {
+      participantLeft:
+        process.env.JITSI_WEBHOOK_PARTICIPANT_LEFT_ENABLED === 'true',
+    },
+  },
   database: {
     host: process.env.DB_HOSTNAME,
     host2: process.env.DB_HOSTNAME2,

src/modules/call/call.controller.spec.ts

@@ -96,8 +96,7 @@ describe('Testing Call Endpoints', () => {
         mockUserToken.payload.email,
       );
       expect(callUseCase.createCallAndRoom).toHaveBeenCalledWith(
-        mockUserToken.payload.uuid,
-        mockUserToken.payload.email,
+        mockUserToken.payload,
       );
       expect(result).toEqual(mockResponse);
     });

src/modules/call/call.controller.ts

@@ -69,7 +69,7 @@ export class CallController {
 
     try {
       await this.callUseCase.validateUserHasNoActiveRoom(uuid, email);
-      const call = await this.callUseCase.createCallAndRoom(uuid, email);
+      const call = await this.callUseCase.createCallAndRoom(user);
       return call;
     } catch (error) {
       const err = error as Error;

src/modules/call/call.service.spec.ts

@@ -7,6 +7,7 @@ import { Test } from '@nestjs/testing';
 import { ConfigModule } from '@nestjs/config';
 import configuration from '../../config/configuration';
 import { createMock, DeepMocked } from '@golevelup/ts-jest';
+import { mockUserPayload } from './fixtures';
 
 jest.mock('uuid');
 jest.mock('jsonwebtoken');
@@ -39,6 +40,7 @@ describe('Call service', () => {
   });
 
   it('When the user has meet enabled, then a call token should be created', async () => {
+    const userPayload = mockUserPayload;
     const getUserTierSpy = jest
       .spyOn(paymentService, 'getUserTier')
       .mockResolvedValue({
@@ -53,18 +55,19 @@ describe('Call service', () => {
     (uuid.v4 as jest.Mock).mockReturnValue('test-room-id');
     (jwt.sign as jest.Mock).mockReturnValue('test-jitsi-token');
 
-    const result = await callService.createCallToken('user-123');
+    const result = await callService.createCallToken(userPayload);
 
     expect(result).toEqual({
       token: 'test-jitsi-token',
       room: 'test-room-id',
       paxPerCall: 10,
     });
 
-    expect(getUserTierSpy).toHaveBeenCalledWith('user-123');
+    expect(getUserTierSpy).toHaveBeenCalledWith(userPayload.uuid);
   });
 
   it('When the user does not have meet enabled, then an error indicating so is thrown', async () => {
+    const userPayload = mockUserPayload;
     const getUserTierSpy = jest
       .spyOn(paymentService, 'getUserTier')
       .mockResolvedValue({
@@ -76,16 +79,17 @@ describe('Call service', () => {
         },
       } as Tier);
 
-    await expect(callService.createCallToken('user-123')).rejects.toThrow(
+    await expect(callService.createCallToken(userPayload)).rejects.toThrow(
       UnauthorizedException,
     );
 
-    expect(getUserTierSpy).toHaveBeenCalledWith('user-123');
+    expect(getUserTierSpy).toHaveBeenCalledWith(userPayload.uuid);
   });
 
   describe('createCallTokenForParticipant', () => {
     it('should create a token for a registered user', () => {
-      const userId = 'test-user-id';
+      const userPayload = mockUserPayload;
+      const userId = userPayload.uuid;
       const roomId = 'test-room-id';
       const isAnonymous = false;
       const expectedToken = 'test-participant-token';
@@ -96,6 +100,7 @@ describe('Call service', () => {
         userId,
         roomId,
         isAnonymous,
+        userPayload,
       );
 
       expect(result).toBe(expectedToken);

src/modules/call/call.service.ts

@@ -7,6 +7,8 @@ import {
   getJitsiJWTPayload,
   getJitsiJWTSecret,
 } from '../../lib/jitsi';
+import { User } from '../user/user.domain';
+import { UserTokenData } from '../auth/dto/user.dto';
 
 export function SignWithRS256AndHeader(
   payload: object,
@@ -48,8 +50,8 @@ export class CallService {
     return meetFeature;
   }
 
-  async createCallToken(userUuid: string) {
-    const meetFeatures = await this.getMeetFeatureConfigForUser(userUuid);
+  async createCallToken(user: User | UserTokenData['payload']) {
+    const meetFeatures = await this.getMeetFeatureConfigForUser(user.uuid);
 
     if (!meetFeatures.enabled)
       throw new UnauthorizedException(
@@ -59,9 +61,9 @@ export class CallService {
     const newRoom = v4();
     const token = generateJitsiJWT(
       {
-        id: userUuid,
-        email: 'example@inxt.com',
-        name: 'Example',
+        id: user.uuid,
+        email: user.email,
+        name: `${user.name} ${user.lastname}`,
       },
       newRoom,
       true,
@@ -74,12 +76,13 @@ export class CallService {
     userId: string,
     roomId: string,
     isAnonymous: boolean,
+    user?: User | UserTokenData['payload'],
   ) {
     const token = generateJitsiJWT(
       {
         id: userId,
-        email: isAnonymous ? 'anonymous@inxt.com' : 'user@inxt.com',
-        name: isAnonymous ? 'Anonymous' : 'User',
+        email: isAnonymous ? 'anonymous@inxt.com' : user.email,
+        name: isAnonymous ? 'Anonymous' : `${user.name} ${user.lastname}`,
       },
       roomId,
       false,

src/modules/call/call.usecase.spec.ts

@@ -102,12 +102,9 @@ describe('CallUseCase', () => {
         .spyOn(callUseCase, 'createRoomForCall')
         .mockResolvedValueOnce();
 
-      const result = await callUseCase.createCallAndRoom(
-        mockUserPayload.uuid,
-        mockUserPayload.email,
-      );
+      const result = await callUseCase.createCallAndRoom(mockUserPayload);
 
-      expect(createCallTokenSpy).toHaveBeenCalledWith(mockUserPayload.uuid);
+      expect(createCallTokenSpy).toHaveBeenCalledWith(mockUserPayload);
       expect(createRoomForCallSpy).toHaveBeenCalledWith(
         mockCallResponse,
         mockUserPayload.uuid,
@@ -123,13 +120,10 @@ describe('CallUseCase', () => {
         .mockRejectedValueOnce(error);
 
       await expect(
-        callUseCase.createCallAndRoom(
-          mockUserPayload.uuid,
-          mockUserPayload.email,
-        ),
+        callUseCase.createCallAndRoom(mockUserPayload),
       ).rejects.toThrow(error);
 
-      expect(createCallTokenSpy).toHaveBeenCalledWith(mockUserPayload.uuid);
+      expect(createCallTokenSpy).toHaveBeenCalledWith(mockUserPayload);
     });
   });
 

src/modules/call/call.usecase.ts

@@ -13,6 +13,8 @@ import { RoomUserUseCase } from '../room/room-user.usecase';
 import { JoinCallResponseDto } from './dto/join-call.dto';
 import { v4 as uuidv4 } from 'uuid';
 import { CreateCallResponseDto } from './dto/create-call.dto';
+import { User } from '../user/user.domain';
+import { UserTokenData } from '../auth/dto/user.dto';
 
 @Injectable()
 export class CallUseCase {
@@ -54,19 +56,18 @@ export class CallUseCase {
   }
 
   async createCallAndRoom(
-    uuid: string,
-    email: string,
+    user: User | UserTokenData['payload'],
   ): Promise<CreateCallResponseDto> {
     try {
-      const call = await this.callService.createCallToken(uuid);
-      await this.createRoomForCall(call, uuid, email);
-      this.logger.log(`Successfully created call for user: ${email}`);
+      const call = await this.callService.createCallToken(user);
+      await this.createRoomForCall(call, user.uuid, user.email);
+      this.logger.log(`Successfully created call for user: ${user.email}`);
       return call;
     } catch (error) {
       const err = error as Error;
       this.logger.error(
         `Failed to create call and room: ${err.message}`,
-        { userId: uuid, email },
+        { userId: user.uuid, email: user.email },
         err.stack,
       );
       throw err;

src/modules/webhook/jitsi/interfaces/JitsiGenericWebHookPayload.ts

@@ -0,0 +1,47 @@
+export enum JitsiGenericWebHookEvent {
+  ROOM_CREATED = 'ROOM_CREATED',
+  PARTICIPANT_LEFT = 'PARTICIPANT_LEFT',
+  PARTICIPANT_LEFT_LOBBY = 'PARTICIPANT_LEFT_LOBBY',
+  TRANSCRIPTION_UPLOADED = 'TRANSCRIPTION_UPLOADED',
+  CHAT_UPLOADED = 'CHAT_UPLOADED',
+  ROOM_DESTROYED = 'ROOM_DESTROYED',
+  PARTICIPANT_JOINED = 'PARTICIPANT_JOINED',
+  PARTICIPANT_JOINED_LOBBY = 'PARTICIPANT_JOINED_LOBBY',
+  RECORDING_STARTED = 'RECORDING_STARTED',
+  RECORDING_ENDED = 'RECORDING_ENDED',
+  RECORDING_UPLOADED = 'RECORDING_UPLOADED',
+  LIVE_STREAM_STARTED = 'LIVE_STREAM_STARTED',
+  LIVE_STREAM_ENDED = 'LIVE_STREAM_ENDED',
+  SETTINGS_PROVISIONING = 'SETTINGS_PROVISIONING',
+  SIP_CALL_IN_STARTED = 'SIP_CALL_IN_STARTED',
+  SIP_CALL_IN_ENDED = 'SIP_CALL_IN_ENDED',
+  SIP_CALL_OUT_STARTED = 'SIP_CALL_OUT_STARTED',
+  SIP_CALL_OUT_ENDED = 'SIP_CALL_OUT_ENDED',
+  FEEDBACK = 'FEEDBACK',
+  DIAL_IN_STARTED = 'DIAL_IN_STARTED',
+  DIAL_IN_ENDED = 'DIAL_IN_ENDED',
+  DIAL_OUT_STARTED = 'DIAL_OUT_STARTED',
+  DIAL_OUT_ENDED = 'DIAL_OUT_ENDED',
+  USAGE = 'USAGE',
+  SPEAKER_STATS = 'SPEAKER_STATS',
+  POLL_CREATED = 'POLL_CREATED',
+  POLL_ANSWER = 'POLL_ANSWER',
+  REACTIONS = 'REACTIONS',
+  AGGREGATED_REACTIONS = 'AGGREGATED_REACTIONS',
+  SCREEN_SHARING_HISTORY = 'SCREEN_SHARING_HISTORY',
+  VIDEO_SEGMENT_UPLOADED = 'VIDEO_SEGMENT_UPLOADED',
+  ROLE_CHANGED = 'ROLE_CHANGED',
+  RTCSTATS_UPLOADED = 'RTCSTATS_UPLOADED',
+  TRANSCRIPTION_CHUNK_RECEIVED = 'TRANSCRIPTION_CHUNK_RECEIVED',
+}
+
+export interface JitsiGenericWebHookPayload<T = any> {
+  idempotencyKey: string;
+  customerId: string;
+  appId: string;
+  eventType: JitsiGenericWebHookEvent;
+  sessionId: string;
+  timestamp: number;
+  fqn: string;
+  data: T;
+}

src/modules/webhook/jitsi/interfaces/JitsiParticipantLeftData.ts

@@ -0,0 +1,23 @@
+import { JitsiGenericWebHookPayload } from './JitsiGenericWebHookPayload';
+
+export interface JitsiParticipantLeftData {
+  moderator: boolean | 'true' | 'false';
+  name: string;
+  group?: string;
+  email?: string;
+  id?: string;
+  participantJid?: string;
+  participantId: string;
+  avatar?: string;
+  disconnectReason?:
+    | 'left'
+    | 'kicked'
+    | 'unknown'
+    | 'switch_room'
+    | 'unrecoverable_error';
+  participantName?: string;
+  endpointId?: string;
+}
+
+export type JitsiParticipantLeftWebHookPayload =
+  JitsiGenericWebHookPayload<JitsiParticipantLeftData>;

src/modules/webhook/jitsi/interfaces/request.interface.ts

@@ -0,0 +1,5 @@
+import { Request } from 'express';
+
+export interface RequestWithRawBody extends Request {
+  rawBody?: Buffer;
+}