Merge pull request #740 from SuperViz/feat/api-first-participant-initialization

feat: implement api first participant initialization

Author: vitorvargasdev

__mocks__/config.mock.ts

@@ -6,7 +6,6 @@ import { LIMITS_MOCK } from './limits.mock';
 import { WATERMARK_MOCK } from './watermark.mock';
 
 export const MOCK_CONFIG: Configuration = {
-  ablyKey: 'unit-test-ably-key',
   apiKey: 'unit-test-api-key',
   apiUrl: 'http://unit-test-api-url',
   conferenceLayerUrl: 'https://unit-test-conference-layer-url',

src/common/types/sdk-options.types.ts

@@ -11,8 +11,9 @@ export interface SuperVizSdkOptions {
   roomId: string;
   participant: {
     id: string;
-    name: string;
+    name?: string;
     avatar?: Avatar;
+    email?: string;
   };
   group: Group;
   customColors?: ColorsVariables;

src/core/index.test.ts

@@ -88,7 +88,7 @@ describe('initialization errors', () => {
         ...SIMPLE_INITIALIZATION_MOCK,
         participant: undefined as unknown as SuperVizSdkOptions['participant'],
       }),
-    ).rejects.toThrow('Participant name and id is required');
+    ).rejects.toThrow('Participant id is required');
   });
 
   test('should throw an error if no participant id is provided', async () => {
@@ -97,16 +97,7 @@ describe('initialization errors', () => {
         ...SIMPLE_INITIALIZATION_MOCK,
         participant: { name: 'unit-test-participant-name' } as SuperVizSdkOptions['participant'],
       }),
-    ).rejects.toThrow('Participant name and id is required');
-  });
-
-  test('should throw an error if participant name is not provided', async () => {
-    await expect(
-      sdk(UNIT_TEST_API_KEY, {
-        ...SIMPLE_INITIALIZATION_MOCK,
-        participant: { id: 'unit-test-participant-id' } as SuperVizSdkOptions['participant'],
-      }),
-    ).rejects.toThrow('Participant name and id is required');
+    ).rejects.toThrow('Participant id is required');
   });
 
   test('should throw an error if no group name is provided', async () => {
@@ -118,14 +109,6 @@ describe('initialization errors', () => {
     ).rejects.toThrow('Group fields is required');
   });
 
-  test('should throw an error if envoriment is invalid', async () => {
-    ApiService.fetchConfig = jest.fn().mockResolvedValue(undefined);
-
-    expect(sdk(UNIT_TEST_API_KEY, SIMPLE_INITIALIZATION_MOCK)).rejects.toThrow(
-      'Failed to load configuration from server',
-    );
-  });
-
   test('should throw an error if custom colors variables names are invalid', async () => {
     const colorKey = 'invalid-color';
 
@@ -189,4 +172,26 @@ describe('initialization errors', () => {
       '[SuperViz] Participant id is invalid, it should be between 2 and 64 characters and only accept letters, numbers and special characters: -_&@+=,(){}[]/«».:|\'"',
     );
   });
+
+  test('should throw an error if participant email is invalid', async () => {
+    await expect(
+      sdk(UNIT_TEST_API_KEY, {
+        ...SIMPLE_INITIALIZATION_MOCK,
+        participant: { ...SIMPLE_INITIALIZATION_MOCK.participant, email: 'invalid-email' },
+      }),
+    ).rejects.toThrow('[SuperViz] Participant email is invalid');
+  });
+
+  test('should throw an error if participant does not exist and name is not defined', async () => {
+    ApiService.fetchParticipant = jest.fn().mockRejectedValue({});
+
+    await expect(
+      sdk(UNIT_TEST_API_KEY, {
+        ...SIMPLE_INITIALIZATION_MOCK,
+        participant: { ...SIMPLE_INITIALIZATION_MOCK.participant, name: undefined },
+      }),
+    ).rejects.toThrow(
+      '[SuperViz] - Participant does not exist, create the user in the API or add the name in the initialization to initialize the SuperViz room.',
+    );
+  });
 });

src/core/index.ts

@@ -31,6 +31,11 @@ function validateId(id: string): boolean {
   return true;
 }
 
+function validateEmail(email: string): boolean {
+  const emailPattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+  return emailPattern.test(email);
+}
+
 /**
  * @function validateOptions
  * @description Validate the options passed to the SDK
@@ -51,8 +56,8 @@ const validateOptions = ({
     throw new Error('[SuperViz] Group fields is required');
   }
 
-  if (!participant || !participant.id || !participant.name) {
-    throw new Error('[SuperViz] Participant name and id is required');
+  if (!participant || !participant.id) {
+    throw new Error('[SuperViz] Participant id is required');
   }
 
   if (!roomId) {
@@ -70,6 +75,10 @@ const validateOptions = ({
       '[SuperViz] Participant id is invalid, it should be between 2 and 64 characters and only accept letters, numbers and special characters: -_&@+=,(){}[]/«».:|\'"',
     );
   }
+
+  if (participant.email && !validateEmail(participant.email)) {
+    throw new Error('[SuperViz] Participant email is invalid');
+  }
 };
 
 /**
@@ -81,13 +90,13 @@ const validateColorsVariablesNames = (colors: ColorsVariables) => {
   Object.entries(colors).forEach(([key, value]) => {
     if (!Object.values(ColorsVariablesNames).includes(key as ColorsVariablesNames)) {
       throw new Error(
-        `Color ${key} is not a valid color variable name. Please check the documentation for more information.`,
+        `[SuperViz] Color ${key} is not a valid color variable name. Please check the documentation for more information.`,
       );
     }
 
     if (!/^(\d{1,3}\s){2}\d{1,3}$/.test(value)) {
       throw new Error(
-        `Color ${key} is not a valid color variable value. Please check the documentation for more information.`,
+        `[SuperViz] Color ${key} is not a valid color variable value. Please check the documentation for more information.`,
       );
     }
   });
@@ -140,44 +149,56 @@ const init = async (apiKey: string, options: SuperVizSdkOptions): Promise<Launch
     throw new Error('Failed to validate API key');
   }
 
-  const [environment, waterMark, limits] = await Promise.all([
-    ApiService.fetchConfig(apiUrl, apiKey),
+  const [waterMark, limits] = await Promise.all([
     ApiService.fetchWaterMark(apiUrl, apiKey),
     ApiService.fetchLimits(apiUrl, apiKey),
   ]).catch(() => {
-    throw new Error('Failed to load configuration from server');
+    throw new Error('[SuperViz] Failed to load configuration from server');
   });
 
-  if (!environment || !environment.ablyKey) {
-    throw new Error('Failed to load configuration from server');
-  }
-
-  const { ablyKey } = environment;
-  const { participant, roomId, customColors: colors } = options;
+  const { participant, roomId, customColors } = options;
 
   config.setConfig({
     apiUrl,
-    ablyKey,
     apiKey,
     conferenceLayerUrl,
     environment: (options.environment as EnvironmentTypes) ?? EnvironmentTypes.PROD,
     roomId,
     debug: options.debug,
     limits,
     waterMark,
-    colors: options.customColors,
+    colors: customColors,
     features,
   });
 
-  setColorVariables(options.customColors);
+  setColorVariables(customColors);
 
-  ApiService.createOrUpdateParticipant({
-    name: participant.name,
-    participantId: participant.id,
-    avatar: participant.avatar?.imageUrl,
-  });
+  const apiParticipant = await ApiService.fetchParticipant(participant.id).catch(() => null);
 
-  return LauncherFacade(options);
+  if (!apiParticipant && !participant.name) {
+    throw new Error(
+      '[SuperViz] - Participant does not exist, create the user in the API or add the name in the initialization to initialize the SuperViz room.',
+    );
+  }
+
+  if (!apiParticipant) {
+    await ApiService.createParticipant({
+      participantId: participant.id,
+      name: participant?.name,
+      avatar: participant.avatar?.imageUrl,
+      email: participant?.email,
+    });
+  }
+
+  return LauncherFacade({
+    ...options,
+    participant: {
+      id: participant.id,
+      name: participant.name ?? apiParticipant?.name,
+      avatar: participant.avatar ?? apiParticipant?.avatar,
+      email: participant.email ?? apiParticipant?.email,
+    },
+  });
 };
 
 export default init;

src/services/api/index.test.ts

@@ -11,6 +11,14 @@ const CHECK_LIMITS_MOCK = {
   limits: LIMITS_MOCK,
 };
 
+const FETCH_PARTICIPANT_MOCK = {
+  id: 'any_user_id',
+  name: 'any_user_name',
+  email: null,
+  avatar: null,
+  createdAt: '2024-08-13T09:13:09.438Z',
+};
+
 const FETCH_PARTICIPANTS_BY_GROUP_MOCK = [
   {
     id: 'any_user_id',
@@ -33,14 +41,6 @@ jest.mock('../../common/utils', () => {
         return Promise.resolve({ status: 404 });
       }
 
-      if (url.includes('/immersive-config')) {
-        return Promise.resolve(
-          JSON.stringify({
-            ablyKey: MOCK_ABLY_KEY,
-          }),
-        );
-      }
-
       if (url.includes('/user/watermark')) {
         return Promise.resolve({
           message: true,
@@ -81,6 +81,10 @@ jest.mock('../../common/utils', () => {
         return Promise.resolve(FETCH_PARTICIPANTS_BY_GROUP_MOCK);
       }
 
+      if (url.includes('/participants/any_user_id') && method === 'GET') {
+        return Promise.resolve(FETCH_PARTICIPANT_MOCK);
+      }
+
       if (url.includes('/mentions') && method === 'POST') {
         return Promise.resolve({});
       }
@@ -109,15 +113,6 @@ describe('ApiService', () => {
     });
   });
 
-  describe('fetchConfig', () => {
-    test('should return the config', async () => {
-      const baseUrl = 'https://dev.nodeapi.superviz.com';
-      const response = await ApiService.fetchConfig(baseUrl, VALID_API_KEY);
-
-      expect(response).toBe(JSON.stringify({ ablyKey: MOCK_ABLY_KEY }));
-    });
-  });
-
   describe('fetchWatermark', () => {
     test('should return the watermark', async () => {
       const baseUrl = 'https://dev.nodeapi.superviz.com';
@@ -233,4 +228,12 @@ describe('ApiService', () => {
       expect(response).toEqual({});
     });
   });
+
+  describe('fetchParticipant', () => {
+    test('should return the participant', async () => {
+      const response = await ApiService.fetchParticipant('any_user_id');
+
+      expect(response).toEqual(FETCH_PARTICIPANT_MOCK);
+    });
+  });
 });

src/services/api/index.ts

@@ -7,7 +7,7 @@ import { ComponentLimits } from '../limits/types';
 import {
   AnnotationParams,
   CommentParams,
-  CreateOrUpdateParticipantParams,
+  CreateParticipantParams,
   FetchAnnotationsParams,
   MentionParams,
 } from './types';
@@ -105,15 +105,22 @@ export default class ApiService {
     return doRequest(url, 'DELETE', {}, { apikey: apiKey });
   }
 
-  static async createOrUpdateParticipant(
-    participant: CreateOrUpdateParticipantParams,
+  static async createParticipant(
+    participant: CreateParticipantParams,
   ): Promise<void> {
     const baseUrl = config.get<string>('apiUrl');
     const path = '/participants';
     const url = this.createUrl(baseUrl, path);
     return doRequest(url, 'POST', { ...participant }, { apikey: config.get<string>('apiKey') });
   }
 
+  static async fetchParticipant(id: string) {
+    const baseUrl = config.get<string>('apiUrl');
+    const path = `/participants/${id}`;
+    const url = this.createUrl(baseUrl, path);
+    return doRequest(url, 'GET', undefined, { apikey: config.get<string>('apiKey') });
+  }
+
   static async sendActivity(userId: string, groupId: string, groupName: string, product: string) {
     const path = '/activity';
     const baseUrl = config.get<string>('apiUrl');

src/services/api/types.ts

@@ -26,8 +26,9 @@ export type MentionParticipantParams = {
   readed: number
 }
 
-export type CreateOrUpdateParticipantParams = {
-  name: string;
+export type CreateParticipantParams = {
+  name?: string;
   participantId: string;
-  avatar: string | null;
+  avatar?: string | null;
+  email?: string
 };

src/services/config/index.test.ts

@@ -13,7 +13,6 @@ describe('ConfigurationService', () => {
 
   describe('setConfig', () => {
     test('configuration should be set correctly', () => {
-      expect(configService.get('ablyKey')).toEqual(MOCK_CONFIG.ablyKey);
       expect(configService.get('apiKey')).toEqual(MOCK_CONFIG.apiKey);
       expect(configService.get('apiUrl')).toEqual(MOCK_CONFIG.apiUrl);
       expect(configService.get('conferenceLayerUrl')).toEqual(MOCK_CONFIG.conferenceLayerUrl);
@@ -24,8 +23,8 @@ describe('ConfigurationService', () => {
 
   describe('get', () => {
     test('should get a value from configuration', () => {
-      const result = configService.get('ablyKey', 'defaultValue');
-      expect(result).toBe(MOCK_CONFIG.ablyKey);
+      const result = configService.get('apiKey', 'defaultValue');
+      expect(result).toBe(MOCK_CONFIG.apiKey);
     });
 
     test('should provide a default value if key is not found', () => {
@@ -35,7 +34,7 @@ describe('ConfigurationService', () => {
 
     test('should return the default value if the config is not available', () => {
       configService.setConfig(null as unknown as Configuration);
-      expect(configService.get('ablyKey')).toBeUndefined();
+      expect(configService.get('apiKey')).toBeUndefined();
     });
   });
 });

src/services/config/types.ts

@@ -7,7 +7,6 @@ export interface Configuration {
   roomId: string;
   environment: EnvironmentTypes;
   apiKey: string;
-  ablyKey: string;
   apiUrl: string;
   conferenceLayerUrl: string;
   debug: boolean;

src/services/video-conference-manager/index.ts

@@ -104,7 +104,6 @@ export default class VideoConfereceManager {
     this.frameConfig = {
       apiKey: config.get<string>('apiKey'),
       apiUrl: config.get<string>('apiUrl'),
-      ablyKey: config.get<string>('ablyKey'),
       debug: config.get<boolean>('debug'),
       roomId: config.get<string>('roomId'),
       limits: config.get<ComponentLimits>('limits'),

src/services/video-conference-manager/types.ts

@@ -64,7 +64,6 @@ export interface FrameLocale {
 export interface FrameConfig {
   apiKey: string;
   apiUrl: string;
-  ablyKey: string;
   roomId: string;
   debug: boolean;
   limits: ComponentLimits;