@tarunzyraclavis/zyra-twilio-wrapper 1.0.0 → 1.0.8

package/dist/index.mjs

@@ -36,19 +36,56 @@ function createErrorResult(error) {
 
 // src/index.ts
 var ZyraTwilioWrapper = class {
-  constructor(configObj) {
+  constructor(config) {
     this.device = null;
     this.activeConnection = null;
     this.isInitialized = false;
     this.isInitializing = false;
+    this.isAuthenticated = false;
+    this.axiosInstance = axios2.create();
     this.activeCallSid = null;
     this.conferenceDetail = null;
     this.participants = [];
     this.waitUrl = "https://api.twilio.com/cowbell.mp3";
-    this.serverUrl = configObj.serverUrl;
-    this.identity = configObj.identity;
-    this.waitUrl = configObj.waitUrl || this.waitUrl;
-    this.conferenceName = `conf_${this.identity}`;
+    this.serverUrl = config.serverUrl;
+    this.identity = config.identity;
+    this.sdkToken = config.sdkToken;
+    this.waitUrl = config.waitUrl || this.waitUrl;
+    this.conferenceName = `conf_${this.identity}_${Date.now()}`;
+  }
+  /* ------------------------------------------------------------------ */
+  /* AUTH                                                               */
+  /* ------------------------------------------------------------------ */
+  setupAxiosAuth(token) {
+    this.axiosInstance.defaults.headers.common["Authorization"] = `Bearer ${token}`;
+  }
+  ensureAuthenticated() {
+    if (!this.isAuthenticated) {
+      throw new Error("SDK not authenticated.");
+    }
+  }
+  async verifySDKToken() {
+    if (!this.sdkToken) {
+      throw new Error("SDK token not provided");
+    }
+    try {
+      const res = await this.axiosInstance.post(
+        `${this.serverUrl}/voipSdk.verifySdkToken`,
+        {},
+        { headers: { Authorization: `Bearer ${this.sdkToken}` } }
+      );
+      console.log("verifySDKToken :", res.data.result.data.verified);
+      if (res?.data?.result?.data?.verified) {
+        this.isAuthenticated = true;
+        this.setupAxiosAuth(this.sdkToken);
+        console.info("[verifySDKToken] SDK token verified");
+        return true;
+      }
+      throw new Error("Invalid SDK token");
+    } catch (error) {
+      this.isAuthenticated = false;
+      throw new Error("SDK authentication failed");
+    }
   }
   // /**
   //  * Initialize the Twilio device and get token
@@ -60,31 +97,21 @@ var ZyraTwilioWrapper = class {
   * @returns Promise that resolves when initialization is complete
   */
   async init() {
+    this.ensureAuthenticated();
     if (this.isInitialized) {
-      throw new Error(
-        "SDK is already initialized. Call destroy() first to reinitialize."
-      );
+      throw new Error("SDK already initialized");
     }
     if (this.isInitializing) {
-      throw new Error("SDK initialization is already in progress");
+      throw new Error("SDK initialization already in progress");
     }
     this.isInitializing = true;
     try {
-      if (!this.serverUrl) {
-        throw new Error("serverUrl is required");
-      }
-      if (!this.identity) {
-        throw new Error("identity is required");
-      }
       const token = await this.generateToken();
-      this.device = new Device(token, { logLevel: 3 });
+      this.device = new Device(token, { logLevel: "info" });
       this.setupDeviceEventHandlers();
       await this.device.register();
       this.isInitialized = true;
-      console.info("[init] Device registration completed");
-    } catch (error) {
-      handleAxiosError(error, this.onError, "Failed to fetch token");
-      throw error;
+      console.info("[init] Device registered");
     } finally {
       this.isInitializing = false;
     }
@@ -93,341 +120,217 @@ var ZyraTwilioWrapper = class {
   async generateToken() {
     try {
       const payload = {
-        identity: this.identity,
-        ttl: 3600,
-        incomingAllow: true
+        json: {
+          identity: this.identity,
+          ttl: 3600,
+          incomingAllow: true
+        }
       };
-      const res = await axios2.post(`${this.serverUrl}/voipSdk.generateToken`, payload);
-      const token = res.data.result.data.token;
-      if (!token) {
-        throw new Error("Token not found in server response");
-      }
+      console.log("Generating token with payload:", payload);
+      const res = await this.axiosInstance.post(
+        `https://nextdev.zyratalk.com/api/trpc/voipSdk.generateToken`,
+        payload
+      );
+      const token = res?.data?.result?.data?.token;
+      if (!token) throw new Error("Token missing");
       return token;
     } catch (error) {
-      handleAxiosError(error, this.onError, "Failed to generate Twilio token");
+      handleAxiosError(error, this.onError, "Token generation failed");
       throw error;
     }
   }
-  // Private methods for handling the event for device
   setupDeviceEventHandlers() {
     if (!this.device) return;
-    this.device.on("registered", () => {
-      console.info("[Device] Registered");
-      this.onReady?.();
-    });
+    this.device.on("registered", () => this.onReady?.());
     this.device.on("incoming", (conn) => {
-      console.info("[Device] Incoming call detected");
+      this.activeConnection = conn;
       conn.on("cancel", () => {
-        console.warn("[Device] Caller hung up before answer");
         this.activeConnection = null;
         this.onMissedCall?.();
       });
-      conn.on("reject", () => {
-        console.warn("[Device] Call rejected");
-        this.activeConnection = null;
-      });
+      conn.on("reject", () => this.activeConnection = null);
       conn.on("accept", () => console.info("[Device] Call accepted"));
-      this.activeConnection = conn;
       this.onIncoming?.(conn);
     });
-    this.device.on("disconnect", () => {
-      console.info("[Device] Call disconnected");
-      this.activeConnection = null;
-      this.onDisconnect?.();
-    });
     this.device.on("connect", (conn) => {
-      console.info("[Device] Call connected");
       this.activeConnection = conn;
       this.onConnect?.(conn);
     });
+    this.device.on("disconnect", () => {
+      this.activeConnection = null;
+      this.onDisconnect?.();
+    });
     this.device.on("error", (error) => {
-      handleAxiosError(error, this.onError, "Device encountered an error");
+      handleAxiosError(error, this.onError, "Device error");
+    });
+    this.device.on("tokenWillExpire", async () => {
+      const token = await this.generateToken();
+      this.device?.updateToken(token);
     });
   }
+  /* ------------------------------------------------------------------ */
+  /* CALL CONTROL                                                        */
+  /* ------------------------------------------------------------------ */
   /**
-   * Check if SDK is initialized
-   */
-  get initialized() {
-    return this.isInitialized;
-  }
-  /**
-   * Destroy the SDK instance and clean up resources
-   */
-  destroy() {
-    if (this.device) {
-      this.device.removeAllListeners();
-      this.device.on("error", (error) => {
-        handleAxiosError(error, this.onError, "Device encountered an error during destroy");
-      });
-      this.device.on("tokenWillExpire", async () => {
-        const token = await this.generateToken();
-        this.device?.updateToken(token);
-      });
-      this.device.destroy();
-      this.device = null;
-    }
-    this.isInitialized = false;
-    this.isInitializing = false;
-    this.activeConnection = null;
-    console.info("[destroy] Device destroyed and SDK state reset");
-  }
-  /**
-   * Make an outgoing call or add participant to an existing call
-   */
+  * Make an outgoing call or add participant to an existing call
+  */
   async makeCall(to) {
-    if (!this.device) {
-      return createErrorResult("Device not initialized");
-    }
-    if (!to) {
-      console.warn("[makeCall] 'to' parameter is required");
-      return createErrorResult("[makeCall] 'to' parameter is required");
-    }
+    this.ensureAuthenticated();
+    if (!this.device) return createErrorResult("Device not initialized");
+    if (!to) return createErrorResult("Destination required");
     if (!this.activeConnection) {
-      try {
-        const connection = await this.device.connect({
-          params: { To: to, conferenceName: this.conferenceName }
-        });
-        this.activeConnection = connection;
-        connection.on("accept", async (conn) => {
-          this.activeCallSid = connection?.parameters?.CallSid ?? null;
-          console.info(`[makeCall] Call accepted. Call SID: ${this.activeCallSid}`);
-          this.onAnswerOutGoing?.(conn);
-          await this.getConferenceId();
-        });
-        connection.on("error", (error) => {
-          console.error("[makeCall] Connection error:", error.message);
-          this.onError?.(error);
-        });
-        connection.on("disconnect", () => {
-          console.info("[makeCall] Call disconnected.");
-          this.activeConnection = null;
-          this.onDisconnect?.();
-        });
-        console.info(`[makeCall] Outgoing call initiated to: ${to}`);
-        return createSuccessResult(`[makeCall] Outgoing call initiated to: ${to}`, connection);
-      } catch (error) {
-        const err = error instanceof Error ? error : new Error(String(error));
-        console.error("[makeCall] Failed to initiate call:", err.message);
-        this.onError?.(err);
-        return createErrorResult(`[makeCall] Failed to initiate call: ${err.message}`);
-      }
-    } else {
-      try {
-        console.info("[makeCall] Active call found. Holding and adding new participant...");
-        await this.holdAndAddParticipant(this.activeConnection.parameters.CallSid, to);
-        return createSuccessResult(`[makeCall] Outgoing participant  ${to} added`, this.activeConnection);
-      } catch (error) {
-        const err = error instanceof Error ? error : new Error(String(error));
-        console.error("[makeCall] Failed to add participant:", err.message);
-        this.onError?.(err);
-        return createErrorResult(`[makeCall] Failed to add participant: ${err.message}`);
-      }
+      const conn = await this.device.connect({
+        params: { To: to, conferenceName: this.conferenceName }
+      });
+      this.activeConnection = conn;
+      conn.on("accept", async () => {
+        this.activeCallSid = conn.parameters?.CallSid ?? null;
+        await this.getConferenceId();
+      });
+      return createSuccessResult("Call started", conn);
     }
+    await this.holdAndAddParticipant(
+      this.activeConnection.parameters.CallSid,
+      to
+    );
+    return createSuccessResult("Participant added", this.activeConnection);
   }
   /**
-   * Accept incoming call
-   */
+  * Accept incoming call
+  */
   acceptCall() {
-    if (!this.device || !this.activeConnection) {
-      const msg = !this.device ? "Device not initialized." : "No active call to accept.";
-      console.warn(`[acceptCall] ${msg}`);
-      return createErrorResult(`[acceptCall] ${msg}`);
-    }
-    try {
-      this.activeConnection.accept();
-      console.info("[acceptCall] Call accepted successfully.");
-      return createSuccessResult("Call accepted successfully.", this.activeConnection);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      console.error("[acceptCall] Failed:", err.message);
-      this.onError?.(err);
-      return createErrorResult(`[acceptCall] Failed: ${err.message}`);
+    if (!this.activeConnection) {
+      return createErrorResult("No incoming call");
     }
+    this.activeConnection.accept();
+    return createSuccessResult("Call accepted", this.activeConnection);
   }
   /**
-   * Hang up active call
-   */
+  * Hang up active call
+  */
   hangup() {
-    if (!this.device || !this.activeConnection) {
-      const msg = !this.device ? "Device not initialized." : "No active call to hang up.";
-      console.warn(`[hangup] ${msg}`);
-      return createErrorResult(`[hangup] ${msg}`);
-    }
-    try {
-      this.device.disconnectAll();
-      this.activeConnection = null;
-      console.info("[hangup] Call hung up successfully.");
-      return createSuccessResult("Call hung up successfully.", this.activeConnection);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      console.error("[hangup] Failed:", err.message);
-      this.onError?.(err);
-      return createErrorResult(`Failed to hang up: ${err.message}`);
-    }
+    if (!this.device) return createErrorResult("Device not initialized");
+    this.device.disconnectAll();
+    this.activeConnection = null;
+    return createSuccessResult("Call ended", null);
   }
   /**
-   * Reject incoming call
-   */
+  * Reject incoming call
+  */
   rejectCall() {
-    if (!this.device || !this.activeConnection) {
-      const msg = !this.device ? "Device not initialized." : "No active call to reject.";
-      console.warn(`[rejectCall] ${msg}`);
-      return createErrorResult(`[rejectCall] ${msg}`);
-    }
-    try {
-      this.activeConnection.reject();
-      this.activeConnection = null;
-      console.info("[rejectCall] Call rejected successfully.");
-      return createSuccessResult("[rejectCall] Call rejected successfully.", this.activeConnection);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      console.error("[rejectCall] Failed:", err.message);
-      this.onError?.(err);
-      return createErrorResult(`Failed to reject call: ${err.message}`);
-    }
+    if (!this.activeConnection) return createErrorResult("No call to reject");
+    this.activeConnection.reject();
+    this.activeConnection = null;
+    return createSuccessResult("Call rejected", null);
   }
   /**
-   * Toggle mute/unmute
-   */
+  * Toggle mute/unmute
+  */
   toggleMute(mute) {
-    if (!this.activeConnection) {
-      console.warn("[toggleMute] No active call to mute/unmute.");
-      return createErrorResult("[toggleMute] No active call to mute/unmute.");
-    }
-    try {
-      this.activeConnection.mute(mute);
-      console.info(`[toggleMute] Call ${mute ? "muted" : "unmuted"} successfully.`);
-      return createSuccessResult(`Call ${mute ? "muted" : "unmuted"} successfully.`, this.activeConnection);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      console.error("[toggleMute] Failed:", err.message);
-      this.onError?.(err);
-      return createErrorResult(`Failed to toggle mute: ${err.message}`);
-    }
+    if (!this.activeConnection) return createErrorResult("No active call");
+    this.activeConnection.mute(mute);
+    return createSuccessResult(`Mute ${mute}`, this.activeConnection);
   }
+  /* ------------------------------------------------------------------ */
+  /* CONFERENCE API                                                      */
+  /* ------------------------------------------------------------------ */
   /**
-   * Hold a call
-   */
+  * Hold a call
+  */
   async hold(callSid) {
-    if (!this.activeConnection) return createErrorResult("No active call to hold.");
-    if (!callSid) return createErrorResult("Please provide callSid.");
-    try {
-      const payload = { callSid, conferenceName: this.conferenceName, waitUrl: this.waitUrl };
-      await axios2.post(`${this.serverUrl}/outgoingCall.hold`, payload);
-      console.info("[hold] Call held successfully.");
-      return createSuccessResult("Call held successfully.", this.activeConnection);
-    } catch (error) {
-      handleAxiosError(error, this.onError, "Failed to hold call");
-      const errMessage = error instanceof Error ? error.message : String(error);
-      return createErrorResult(`Failed to hold call: ${errMessage}`);
-    }
+    this.ensureAuthenticated();
+    const payload = {
+      callSid,
+      conferenceName: this.conferenceName,
+      waitUrl: this.waitUrl
+    };
+    await this.axiosInstance.post(`${this.serverUrl}/outgoingCall.hold`, payload);
+    return createSuccessResult("Call held", this.activeConnection);
   }
   /**
-   * Resume a held call
-   */
+  * Resume a held call
+  */
   async resume(callSid) {
-    if (!this.activeConnection) return createErrorResult("No active call to resume.");
-    if (!callSid) return createErrorResult("Please provide callSid.");
-    try {
-      const payload = { callSid, conferenceName: this.conferenceName };
-      await axios2.post(`${this.serverUrl}/outgoingCall.unhold`, payload);
-      console.info("[resume] Call resumed successfully.");
-      return createSuccessResult("Call resumed successfully.", this.activeConnection);
-    } catch (error) {
-      handleAxiosError(error, this.onError, "Failed to resume call");
-      const errMessage = error instanceof Error ? error.message : String(error);
-      return createErrorResult(`Failed to resume call: ${errMessage}`);
-    }
+    this.ensureAuthenticated();
+    const payload = {
+      callSid,
+      conferenceName: this.conferenceName
+    };
+    await this.axiosInstance.post(
+      `${this.serverUrl}/outgoingCall.unhold`,
+      payload
+    );
+    return createSuccessResult("Call resumed", this.activeConnection);
   }
   /**
-   * Hold active call and add a new participant
-   */
-  async holdAndAddParticipant(callSid, newParticipantNo) {
-    if (!this.activeConnection) return createErrorResult("No active call.");
-    if (!callSid) return createErrorResult("Please provide callSid.");
-    if (!newParticipantNo) return createErrorResult("Please provide participant number.");
-    try {
-      const holdPayload = { conferenceName: this.conferenceName, callSid, waitUrl: this.waitUrl };
-      const holdRes = await axios2.post(`${this.serverUrl}/outgoingCall.hold`, holdPayload);
-      const addPayload = { conferenceName: this.conferenceName, newParticipantNo };
-      const addRes = await axios2.post(`${this.serverUrl}/outgoingCall.addNewCallee`, addPayload);
-      console.info("[holdAndAddParticipant] Call held and participant added successfully.");
-      return {
-        message: "Call held and participant added successfully.",
-        status: true,
-        holdResponse: holdRes.data,
-        addParticipantResponse: addRes.data
-      };
-    } catch (error) {
-      handleAxiosError(error, this.onError, "Failed to hold and add participant");
-      const errMessage = error instanceof Error ? error.message : String(error);
-      return createErrorResult(`Failed to hold/add participant: ${errMessage}`);
-    }
+  * Hold active call and add a new participant
+  */
+  async holdAndAddParticipant(callSid, number) {
+    this.ensureAuthenticated();
+    await this.hold(callSid);
+    const payload = {
+      conferenceName: this.conferenceName,
+      newParticipantNo: number
+    };
+    const res = await this.axiosInstance.post(
+      `${this.serverUrl}/outgoingCall.addNewCallee`,
+      payload
+    );
+    return createSuccessResult("Participant added", res.data);
   }
   /**
-   * Fetch conference details
-   */
+       * Fetch conference details
+  */
   async getConferenceId() {
-    if (!this.activeConnection) return createErrorResult("No active call.");
-    const payload = { conferenceName: this.conferenceName };
-    try {
-      const res = await axios2.post(`${this.serverUrl}/outgoingCall.getConferenceId`, payload);
-      if (res?.data?.result?.data) {
-        const confDetails = {
-          conferenceSid: res.data.result.data.conferenceSid,
-          conferences: res.data.result.data.conferences
-        };
-        this.conferenceDetail = confDetails;
-        console.info("[getConferenceId] Conference details fetched successfully.");
-        return createSuccessResult("Call resumed successfully.", confDetails);
-      }
-      console.warn("[getConferenceId] No conference data returned from server.");
-      return { message: "No conference data returned.", status: false };
-    } catch (error) {
-      handleAxiosError(error, this.onError, "Failed to get conference ID");
-      const errMessage = error instanceof Error ? error.message : String(error);
-      return createErrorResult(`Failed to get conference ID: ${errMessage}`);
-    }
+    this.ensureAuthenticated();
+    const payload = {
+      conferenceName: this.conferenceName
+    };
+    const res = await this.axiosInstance.post(
+      `${this.serverUrl}/outgoingCall.getConferenceId`,
+      payload
+    );
+    this.conferenceDetail = res?.data?.result?.data ?? null;
+    return createSuccessResult("Conference fetched", this.conferenceDetail);
   }
   /**
-   * Get participants of a conference
-   */
+  * Get participants of a conference
+  */
   async getParticipants(conferenceSid) {
-    if (!this.activeConnection) return createErrorResult("No active call.");
-    if (!conferenceSid) return createErrorResult("Please provide conferenceSid.");
-    try {
-      const payload = { conferenceSid };
-      const res = await axios2.post(`${this.serverUrl}/outgoingCall.getParticipants`, payload);
-      if (res?.data?.result?.data?.participants) {
-        this.participants = res.data.result.data.participants;
-        console.info("[getParticipants] Participants fetched successfully.");
-        return createSuccessResult("Participants fetched successfully.", this.participants);
-      }
-      console.warn("[getParticipants] No participants returned from server.");
-      return { message: "No participants returned.", status: false };
-    } catch (error) {
-      handleAxiosError(error, this.onError, "Failed to get participants");
-      const errMessage = error instanceof Error ? error.message : String(error);
-      return createErrorResult(`Failed to get participants: ${errMessage}`);
-    }
+    this.ensureAuthenticated();
+    const payload = { conferenceSid };
+    const res = await this.axiosInstance.post(
+      `${this.serverUrl}/outgoingCall.getParticipants`,
+      payload
+    );
+    this.participants = res?.data?.result?.data?.participants ?? [];
+    return createSuccessResult("Participants fetched", this.participants);
   }
   /**
-   * Remove a participant from a conference
-   */
+    * Remove a participant from a conference
+    */
   async removeParticipant(conferenceSid, callSid) {
-    if (!this.activeConnection) return createErrorResult("No active call.");
-    if (!callSid) return createErrorResult("Please provide callSid.");
-    if (!conferenceSid) return createErrorResult("Please provide conferenceSid.");
-    try {
-      const payload = { callSid, conferenceSid };
-      const res = await axios2.post(`${this.serverUrl}/outgoingCall.removeParticipant`, payload);
-      console.info("[removeParticipant] Participant removed successfully.");
-      return createSuccessResult("Participant removed successfully.", res.data);
-    } catch (error) {
-      handleAxiosError(error, this.onError, "Failed to remove participant");
-      const errMessage = error instanceof Error ? error.message : String(error);
-      return createErrorResult(`Failed to remove participant: ${errMessage}`);
+    this.ensureAuthenticated();
+    const payload = { conferenceSid, callSid };
+    const res = await this.axiosInstance.post(
+      `${this.serverUrl}/outgoingCall.removeParticipant`,
+      payload
+    );
+    return createSuccessResult("Participant removed", res.data);
+  }
+  /* ------------------------------------------------------------------ */
+  /* CLEANUP                                                            */
+  /* ------------------------------------------------------------------ */
+  destroy() {
+    if (this.device) {
+      this.device.removeAllListeners();
+      this.device.destroy();
+      this.device = null;
     }
+    this.activeConnection = null;
+    this.isInitialized = false;
+    this.isInitializing = false;
+    this.isAuthenticated = false;
   }
 };
 export {