mediasfu-shared 1.0.0

package/src/methods/welcome/handleWelcomeRequest.ts

@@ -0,0 +1,189 @@
+import { Socket } from 'socket.io-client';
+import Cookies from 'universal-cookie';
+import type { PreJoinPageParameters } from '../../types/types';
+
+const cookies = new Cookies();
+const MAX_ATTEMPTS = 10;
+const RATE_LIMIT_DURATION = 3 * 60 * 60 * 1000; // 3 hours
+
+/**
+ * Options for handleWelcomeRequest function
+ */
+export interface HandleWelcomeRequestOptions {
+  apiUserName: string;
+  apiToken: string;
+  link: string;
+  userName: string;
+  parameters: PreJoinPageParameters;
+}
+
+/**
+ * Validates alphanumeric strings
+ */
+export function validateAlphanumeric(str: string): boolean {
+  if (str.length === 0) return true;
+  const alphanumericRegex = /^[a-zA-Z0-9]+$/;
+  return alphanumericRegex.test(str);
+}
+
+/**
+ * Validates welcome page form inputs
+ */
+export interface ValidateWelcomeInputsOptions {
+  name: string;
+  secret: string;
+  eventID: string;
+  link: string;
+}
+
+export function validateWelcomeInputs({
+  name,
+  secret,
+  eventID,
+  link,
+}: ValidateWelcomeInputsOptions): { valid: boolean; message?: string } {
+  if (name.length === 0 || secret.length === 0 || eventID.length === 0 || link.length === 0) {
+    return { valid: false, message: 'Please fill all the fields.' };
+  }
+
+  if (
+    !validateAlphanumeric(name) ||
+    !validateAlphanumeric(secret) ||
+    !validateAlphanumeric(eventID) ||
+    !link.includes('mediasfu.com') ||
+    eventID.toLowerCase().startsWith('d')
+  ) {
+    return { valid: false, message: 'Please enter valid details.' };
+  }
+
+  if (
+    secret.length != 64 ||
+    name.length > 12 ||
+    name.length < 2 ||
+    eventID.length > 32 ||
+    eventID.length < 8 ||
+    link.length < 12
+  ) {
+    return { valid: false, message: 'Please enter valid details.' };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Handles connection request with rate limiting for welcome page
+ * 
+ * @param {HandleWelcomeRequestOptions} options - Configuration for the request
+ * @returns {Promise<void>}
+ * 
+ * @example
+ * ```typescript
+ * await handleWelcomeRequest({
+ *   apiUserName: 'room123',
+ *   apiToken: 'secret123',
+ *   link: 'https://mediasfu.com/meeting',
+ *   userName: 'John Doe',
+ *   parameters,
+ * });
+ * ```
+ */
+export async function handleWelcomeRequest({
+  apiUserName,
+  apiToken,
+  link,
+  userName,
+  parameters,
+}: HandleWelcomeRequestOptions): Promise<void> {
+  const {
+    showAlert,
+    updateIsLoadingModalVisible,
+    connectSocket,
+    updateSocket,
+    updateValidated,
+    updateApiUserName,
+    updateApiToken,
+    updateLink,
+    updateRoomName,
+    updateMember,
+  } = parameters;
+
+  const TIMEOUT_DURATION = 10000; // 10 seconds
+
+  let unsuccessfulAttempts = parseInt(cookies.get('unsuccessfulAttempts') || '0');
+  let lastRequestTimestamp = parseInt(cookies.get('lastRequestTimestamp') || '0');
+
+  if (unsuccessfulAttempts >= MAX_ATTEMPTS) {
+    if (Date.now() - lastRequestTimestamp < RATE_LIMIT_DURATION) {
+      showAlert?.({
+        message: 'Too many unsuccessful attempts. Please try again later.',
+        type: 'danger',
+        duration: 3000,
+      });
+      cookies.set('lastRequestTimestamp', Date.now().toString());
+      return;
+    } else {
+      unsuccessfulAttempts = 0;
+      cookies.set('unsuccessfulAttempts', unsuccessfulAttempts.toString());
+      cookies.set('lastRequestTimestamp', Date.now().toString());
+    }
+  }
+
+  try {
+    updateIsLoadingModalVisible(true);
+
+    const socketPromise = connectSocket({
+      apiUserName,
+      apiKey: '',
+      apiToken,
+      link,
+    });
+    const timeoutPromise = new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error('Request timed out')), TIMEOUT_DURATION)
+    );
+
+    const socket = await Promise.race([socketPromise, timeoutPromise]);
+
+    if (socket && socket instanceof Socket && socket.id) {
+      unsuccessfulAttempts = 0;
+      cookies.set('unsuccessfulAttempts', unsuccessfulAttempts.toString());
+      cookies.set('lastRequestTimestamp', Date.now().toString());
+      updateSocket(socket);
+      updateApiUserName(apiUserName);
+      updateApiToken(apiToken);
+      updateLink(link);
+      updateRoomName(apiUserName);
+      updateMember(userName);
+      updateValidated(true);
+    } else {
+      unsuccessfulAttempts += 1;
+      cookies.set('unsuccessfulAttempts', unsuccessfulAttempts.toString());
+      cookies.set('lastRequestTimestamp', Date.now().toString());
+      updateIsLoadingModalVisible(false);
+
+      if (unsuccessfulAttempts >= MAX_ATTEMPTS) {
+        showAlert?.({
+          message: 'Too many unsuccessful attempts. Please try again later.',
+          type: 'danger',
+          duration: 3000,
+        });
+      } else {
+        showAlert?.({
+          message: 'Invalid credentials.',
+          type: 'danger',
+          duration: 3000,
+        });
+      }
+    }
+  } catch {
+    showAlert?.({
+      message: 'Unable to connect. Check your credentials and try again.',
+      type: 'danger',
+      duration: 3000,
+    });
+
+    unsuccessfulAttempts += 1;
+    cookies.set('unsuccessfulAttempts', unsuccessfulAttempts.toString());
+    cookies.set('lastRequestTimestamp', Date.now().toString());
+    updateIsLoadingModalVisible(false);
+  }
+}

package/src/methods/welcome/index.ts

@@ -0,0 +1,5 @@
+export { handleWelcomeRequest, validateAlphanumeric, validateWelcomeInputs } from './handleWelcomeRequest';
+export type {
+  HandleWelcomeRequestOptions,
+  ValidateWelcomeInputsOptions,
+} from './handleWelcomeRequest';

package/src/methods/whiteboard/handleStartWhiteboard.ts

@@ -0,0 +1,65 @@
+import type { Socket } from 'socket.io-client';
+import type { ShowAlert, WhiteboardUser } from '../../types/types';
+
+
+export interface HandleStartWhiteboardOptions {
+  socket: Socket;
+  whiteboardUsers: WhiteboardUser[];
+  roomName: string;
+  whiteboardStarted: boolean;
+  whiteboardEnded: boolean;
+  showAlert?: ShowAlert;
+  updateWhiteboardStarted: (started: boolean) => void;
+  updateWhiteboardEnded: (ended: boolean) => void;
+  updateIsConfigureWhiteboardModalVisible: (isVisible: boolean) => void;
+}
+
+export type HandleStartWhiteboardType = (options: HandleStartWhiteboardOptions) => Promise<boolean>;
+
+/**
+ * Handles the start of a whiteboard session.
+ * @function
+ * @param {HandleStartWhiteboardOptions} options - The options for starting the whiteboard.
+ * @param {Socket} options.socket - The socket instance for communication.
+ * @param {WhiteboardUser[]} options.whiteboardUsers - Array of users assigned to the whiteboard.
+ * @param {string} options.roomName - The name of the room.
+ * @param {boolean} options.whiteboardStarted - Whether the whiteboard has already started.
+ * @param {boolean} options.whiteboardEnded - Whether the whiteboard has ended.
+ * @param {ShowAlert} [options.showAlert] - Function to show alerts.
+ * @param {Function} options.updateWhiteboardStarted - Function to update whiteboard started state.
+ * @param {Function} options.updateWhiteboardEnded - Function to update whiteboard ended state.
+ * @param {Function} options.updateIsConfigureWhiteboardModalVisible - Function to close the configure modal.
+ * @returns {Promise<boolean>}
+ */
+export const handleStartWhiteboard = async ({
+  socket,
+  whiteboardUsers,
+  roomName,
+  whiteboardStarted,
+  whiteboardEnded,
+  showAlert,
+  updateWhiteboardStarted,
+  updateWhiteboardEnded,
+  updateIsConfigureWhiteboardModalVisible,
+}: HandleStartWhiteboardOptions): Promise<boolean> => {
+  const emitName = whiteboardStarted && !whiteboardEnded ? 'updateWhiteboard' : 'startWhiteboard';
+  const filteredWhiteboardUsers = whiteboardUsers.map(({ name, useBoard }) => ({ name, useBoard }));
+
+  return new Promise((resolve) => {
+    socket.emit(
+      emitName,
+      { whiteboardUsers: filteredWhiteboardUsers, roomName },
+      (response: { success: boolean; reason?: string }) => {
+        if (response.success) {
+          showAlert?.({ message: 'Whiteboard active', type: 'success' });
+          updateWhiteboardStarted(true);
+          updateWhiteboardEnded(false);
+          updateIsConfigureWhiteboardModalVisible(false);
+        } else {
+          showAlert?.({ message: response.reason || 'Failed to start whiteboard', type: 'danger' });
+        }
+        resolve(response.success);
+      }
+    );
+  });
+};

package/src/methods/whiteboard/handleStopWhiteboard.ts

@@ -0,0 +1,48 @@
+import type { Socket } from 'socket.io-client';
+import type { ShowAlert } from '../../types/types';
+
+export interface HandleStopWhiteboardOptions {
+  socket: Socket;
+  roomName: string;
+  showAlert?: ShowAlert;
+  updateWhiteboardStarted: (started: boolean) => void;
+  updateWhiteboardEnded: (ended: boolean) => void;
+  updateIsConfigureWhiteboardModalVisible: (isVisible: boolean) => void;
+}
+
+export type HandleStopWhiteboardType = (options: HandleStopWhiteboardOptions) => Promise<boolean>;
+
+/**
+ * Handles stopping a whiteboard session.
+ * @function
+ * @param {HandleStopWhiteboardOptions} options - The options for stopping the whiteboard.
+ * @param {Socket} options.socket - The socket instance for communication.
+ * @param {string} options.roomName - The name of the room.
+ * @param {ShowAlert} [options.showAlert] - Function to show alerts.
+ * @param {Function} options.updateWhiteboardStarted - Function to update whiteboard started state.
+ * @param {Function} options.updateWhiteboardEnded - Function to update whiteboard ended state.
+ * @param {Function} options.updateIsConfigureWhiteboardModalVisible - Function to close the configure modal.
+ * @returns {Promise<boolean>}
+ */
+export const handleStopWhiteboard = async ({
+  socket,
+  roomName,
+  showAlert,
+  updateWhiteboardStarted,
+  updateWhiteboardEnded,
+  updateIsConfigureWhiteboardModalVisible,
+}: HandleStopWhiteboardOptions): Promise<boolean> => {
+  return new Promise((resolve) => {
+    socket.emit('stopWhiteboard', { roomName }, (response: { success: boolean; reason?: string }) => {
+      if (response.success) {
+        showAlert?.({ message: 'Whiteboard stopped', type: 'success' });
+        updateWhiteboardStarted(false);
+        updateWhiteboardEnded(true);
+        updateIsConfigureWhiteboardModalVisible(false);
+      } else {
+        showAlert?.({ message: response.reason || 'Failed to stop whiteboard', type: 'danger' });
+      }
+      resolve(response.success);
+    });
+  });
+};

package/src/methods/whiteboard/index.ts

@@ -0,0 +1,4 @@
+export { handleStartWhiteboard } from './handleStartWhiteboard';
+export type { HandleStartWhiteboardOptions, HandleStartWhiteboardType } from './handleStartWhiteboard';
+export { handleStopWhiteboard } from './handleStopWhiteboard';
+export type { HandleStopWhiteboardOptions, HandleStopWhiteboardType } from './handleStopWhiteboard';

package/src/methods/whiteboard/launchConfigureWhiteboard.ts

@@ -0,0 +1,29 @@
+export interface LaunchConfigureWhiteboardOptions {
+  updateIsConfigureWhiteboardModalVisible: (visible: boolean) => void
+  isConfigureWhiteboardModalVisible: boolean
+}
+
+export type LaunchConfigureWhiteboardType = (options: LaunchConfigureWhiteboardOptions) => void
+
+/**
+ * Toggles the visibility of the configure whiteboard modal.
+ *
+ * @param {LaunchConfigureWhiteboardOptions} options - The options for toggling the whiteboard modal visibility.
+ * @param {Function} options.updateIsConfigureWhiteboardModalVisible - Function to update the visibility state of the configure whiteboard modal.
+ * @param {boolean} options.isConfigureWhiteboardModalVisible - Current visibility state of the configure whiteboard modal.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   updateIsConfigureWhiteboardModalVisible: (visible: boolean) => console.log('Modal visibility updated:', visible),
+ *   isConfigureWhiteboardModalVisible: false,
+ * }
+ * launchConfigureWhiteboard(options)
+ * ```
+ */
+export const launchConfigureWhiteboard: LaunchConfigureWhiteboardType = ({
+  updateIsConfigureWhiteboardModalVisible,
+  isConfigureWhiteboardModalVisible,
+}) => {
+  updateIsConfigureWhiteboardModalVisible(!isConfigureWhiteboardModalVisible)
+}

package/src/producers/producerEmits/joinConRoom.ts

@@ -0,0 +1,153 @@
+import { Socket } from "socket.io-client";
+import { validateAlphanumeric } from "../../methods/utils/validateAlphanumeric"; // Import the validateAlphanumeric function from the validateAlphanumeric file
+import type { RtpCapabilities } from "mediasoup-client/lib/types";
+
+export interface JoinConRoomOptions {
+  socket: Socket;
+  roomName: string;
+  islevel: string;
+  member: string;
+  sec: string;
+  apiUserName: string;
+}
+
+export interface JoinConRoomResponse {
+  success: boolean;
+  rtpCapabilities: RtpCapabilities | null;
+  reason?: string;
+  banned?: boolean;
+  suspended?: boolean;
+  noAdmin?: boolean;
+  [key: string]: any;
+}
+
+
+// Export the type definition for the function
+export type JoinConRoomType = (options: JoinConRoomOptions) => Promise<JoinConRoomResponse>;
+
+/**
+ * Joins a conference room using the provided options.
+ *
+ * @param {JoinConRoomOptions} options - The options for joining the conference room.
+ * @param {Socket} options.socket - The socket instance to use for communication.
+ * @param {string} options.roomName - The name of the room to join.
+ * @param {string} options.islevel - The level of the user.
+ * @param {string} options.member - The member identifier.
+ * @param {string} options.sec - The security token.
+ * @param {string} options.apiUserName - The API username.
+ * 
+ * @returns {Promise<JoinConRoomResponse>} A promise that resolves with the response of the join operation.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   socket: socketInstance,
+ *   roomName: "s12345678",
+ *   islevel: "1",
+ *   member: "user123",
+ *   sec: "64CharacterLongSecretHere",
+ *   apiUserName: "user123",
+ * };
+ *
+ * try {
+ *   const response = await joinConRoom(options);
+ *   console.log("Room joined:", response);
+ * } catch (error) {
+ *   console.error("Failed to join room:", error);
+ * }
+ * ```
+ */
+
+export async function joinConRoom(
+  { socket, roomName, islevel, member, sec, apiUserName }: JoinConRoomOptions
+): Promise<JoinConRoomResponse> {
+  return new Promise((resolve, reject) => {
+    // Validate inputs
+    if (!(sec && roomName && islevel && apiUserName && member)) {
+      const validationError: JoinConRoomResponse = {
+        success: false,
+        rtpCapabilities: null,
+        reason: "Missing required parameters",
+      };
+      reject(validationError);
+      return;
+    }
+
+    // Validate alphanumeric for roomName, apiUserName, and member
+    try {
+      validateAlphanumeric({ str: roomName });
+      validateAlphanumeric({ str: apiUserName });
+      validateAlphanumeric({ str: member });
+    } catch {
+      const validationError: JoinConRoomResponse = {
+        success: false,
+        rtpCapabilities: null,
+        reason: "Invalid roomName or apiUserName or member",
+      };
+      reject(validationError);
+      return;
+    }
+
+    // Validate roomName starts with 's' or 'p'
+    if (!(roomName.startsWith("s") || roomName.startsWith("p"))) {
+      const validationError: JoinConRoomResponse = {
+        success: false,
+        rtpCapabilities: null,
+        reason: "Invalid roomName, must start with s or p",
+      };
+      reject(validationError);
+      return;
+    }
+
+    // Validate other conditions for sec, roomName, islevel, apiUserName
+    if (
+      !(
+        sec.length === 64 &&
+        roomName.length >= 8 &&
+        islevel.length === 1 &&
+        apiUserName.length >= 6 &&
+        (islevel == "0" || islevel == "1" || islevel == "2")
+      )
+    ) {
+      const validationError: JoinConRoomResponse = {
+        success: false,
+        rtpCapabilities: null,
+        reason: "Invalid roomName or islevel or apiUserName or secret",
+      };
+      reject(validationError);
+      return;
+    }
+
+    socket.emit(
+      "joinConRoom",
+      { roomName, islevel, member, sec, apiUserName },
+      async (data: JoinConRoomResponse) => {
+        try {
+          // Check if rtpCapabilities is null
+          if (data.rtpCapabilities == null) {
+            // Check if banned, suspended, or noAdmin
+            if (data.banned) {
+              throw new Error("User is banned.");
+            }
+            if (data.suspended) {
+              throw new Error("User is suspended.");
+            }
+            if (data.noAdmin) {
+              throw new Error("Host has not joined the room yet.");
+            }
+
+            // Resolve with the data received from the 'joinConRoom' event
+            resolve(data);
+          } else {
+            // Handle other cases or perform additional actions
+            resolve(data);
+          }
+        } catch (error) {
+          // Handle errors during the joinConRoom process
+          console.log("Error joining room:", error);
+          reject(error);
+        }
+      }
+    );
+  });
+}