@tarunzyraclavis/zyra-twilio-wrapper 1.0.0

package/src/index.ts

@@ -0,0 +1,510 @@
+import axios from "axios";
+import { Device, Call } from "@twilio/voice-sdk";
+import { handleAxiosError } from '../utils/errorHandler';
+import {
+  AddParticipantPayload,
+  CallResponse,
+  Config,
+  GetConferencePayload,
+  GetConferenceResult,
+  GetParticipantsPayload,
+  GetParticipantsResult,
+  HoldAndAddResult,
+  HoldCallPayload,
+  HoldPayload,
+  RemoveParticipantPayload,
+  RemoveParticipantResult,
+  ResumeCallPayload,
+  TokenRequestPayload,
+  TokenResponse,
+  TwilioConference,
+  TwilioConferenceParticipant,
+} from '../types/interface';
+import { createSuccessResult, createErrorResult } from '../utils/helper'
+
+export default class ZyraTwilioWrapper {
+  private readonly serverUrl: string;
+  private readonly identity: string;
+  private device: Device | null = null;
+  private activeConnection: Call | null = null;
+  private isInitialized: boolean = false;
+  private isInitializing: boolean = false;
+  public activeCallSid: string | null = null;
+  public conferenceName: string;
+  public conferenceDetail: TwilioConference | null = null;
+  public participants: TwilioConferenceParticipant[] = [];
+  public waitUrl: string = "https://api.twilio.com/cowbell.mp3";
+
+  // Optional event handlers
+  public onReady?: () => void;
+  public onIncoming?: (conn: Call) => void;
+  public onDisconnect?: () => void;
+  public onError?: (error: Error) => void;
+  public onConnect?: (conn: Call) => void;
+  public onMissedCall?: () => void;
+  public onAnswerOutGoing?: (conn: Call) => void;
+
+  constructor(configObj: Config) {
+    this.serverUrl = configObj.serverUrl;
+    this.identity = configObj.identity;
+    this.waitUrl = configObj.waitUrl || this.waitUrl;
+    this.conferenceName = `conf_${this.identity}`;
+  }
+
+  // /**
+  //  * Initialize the Twilio device and get token
+  //  */
+    /**
+   * Initialize the SDK. Can only be called once.
+   * 
+   * @throws {Error} If already initialized or initialization fails
+   * @returns Promise that resolves when initialization is complete
+   */
+public async init(): Promise<void> {
+  if (this.isInitialized) {
+    throw new Error(
+      "SDK is already initialized. Call destroy() first to reinitialize."
+    );
+  }
+
+  if (this.isInitializing) {
+    throw new Error("SDK initialization is already in progress");
+  }
+
+  this.isInitializing = true;
+
+  try {
+    // Validate configuration
+    if (!this.serverUrl) {
+      throw new Error("serverUrl is required");
+    }
+    if (!this.identity) {
+      throw new Error("identity is required");
+    }
+
+    // Generate token and create Device
+    const token = await this.generateToken();
+    this.device = new Device(token, { logLevel: 3 });
+
+    // Setup event handlers
+    this.setupDeviceEventHandlers();
+
+    // Register the device
+    await this.device.register();
+
+    this.isInitialized = true;
+    console.info("[init] Device registration completed");
+  } catch (error: unknown) {
+    handleAxiosError(error, this.onError, "Failed to fetch token");
+    throw error;
+  } finally {
+    // Reset initializing flag even if init fails
+    this.isInitializing = false;
+  }
+}
+
+  // Private methods for get token for initialize the device
+  private async generateToken(): Promise<string> {
+    try {
+      const payload: TokenRequestPayload = {
+          identity: this.identity,
+          ttl: 3600,
+          incomingAllow: true,
+      };
+
+      const res = await axios.post<TokenResponse>(`${this.serverUrl}/voipSdk.generateToken`, payload);
+
+      const token = res.data.result.data.token;
+
+      if (!token) {
+        throw new Error("Token not found in server response");
+      }
+
+      return token;
+    } catch (error : unknown) {
+      handleAxiosError(error, this.onError, "Failed to generate Twilio token");
+      throw error;
+    }
+  }
+
+  // Private methods for handling the event for device
+  private setupDeviceEventHandlers(): void {
+  if (!this.device) return;
+
+  this.device.on("registered", () => {
+    console.info("[Device] Registered");
+    this.onReady?.();
+  });
+
+  this.device.on("incoming", (conn: Call) => {
+    console.info("[Device] Incoming call detected");
+    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("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: Call) => {
+    console.info("[Device] Call connected");
+    this.activeConnection = conn;
+    this.onConnect?.(conn);
+  });
+
+  this.device.on("error", (error: Error) => {
+    handleAxiosError(error, this.onError, "Device encountered an error");
+  });
+}
+
+  /**
+   * Check if SDK is initialized
+   */
+  get initialized(): boolean {
+    return this.isInitialized;
+  }
+  
+  /**
+   * Destroy the SDK instance and clean up resources
+   */
+  public destroy(): void {
+  if (this.device) {
+    // Remove all event listeners
+    this.device.removeAllListeners();
+
+    // Optionally, explicitly handle any final error events
+    this.device.on("error", (error: Error) => {
+      handleAxiosError(error, this.onError, "Device encountered an error during destroy");
+    });
+
+    // When Token expires then get new and update with twilio
+    this.device.on('tokenWillExpire', async () => {
+      const token = await this.generateToken();
+      this.device?.updateToken(token);
+    });
+    // Shutdown device
+    this.device.destroy();
+    this.device = null;
+  }
+
+  // Reset state flags
+  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
+   */
+  public async makeCall(to: string): Promise<CallResponse<Call>> {
+    if (!this.device) {
+      return createErrorResult("Device not initialized");
+    }
+
+    if (!to) {
+      console.warn("[makeCall] 'to' parameter is required");
+      return createErrorResult("[makeCall] 'to' parameter is 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: Call) => {
+          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: 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: unknown) {
+        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: unknown) {
+        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}`);
+      }
+    }
+  }
+
+  /**
+   * Accept incoming call
+   */
+  public acceptCall(): CallResponse<Call> {
+    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: unknown) {
+      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}`);
+    }
+  }
+
+  /**
+   * Hang up active call
+   */
+  public hangup(): CallResponse<Call | null> {
+    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: unknown) {
+      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}`);
+    }
+  }
+
+  /**
+   * Reject incoming call
+   */
+  public rejectCall(): CallResponse<Call | null> {
+    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: unknown) {
+      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}`);
+    }
+  }
+
+  /**
+   * Toggle mute/unmute
+   */
+  public toggleMute(mute: boolean): CallResponse<Call> {
+    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: unknown) {
+      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}`);
+    }
+  }
+
+  /**
+   * Hold a call
+   */
+  public async hold(callSid: string): Promise<CallResponse<Call>> {
+    if (!this.activeConnection) return createErrorResult("No active call to hold.");
+    if (!callSid) return createErrorResult("Please provide callSid.");
+
+    try {
+      const payload: HoldCallPayload = { callSid, conferenceName: this.conferenceName, waitUrl: this.waitUrl };
+      await axios.post(`${this.serverUrl}/outgoingCall.hold`, payload);
+      console.info("[hold] Call held successfully.");
+      return createSuccessResult("Call held successfully.", this.activeConnection);
+
+    } catch (error: unknown) {
+      handleAxiosError(error, this.onError, "Failed to hold call");
+      const errMessage = error instanceof Error ? error.message : String(error);
+      return createErrorResult(`Failed to hold call: ${errMessage}`);
+    }
+  }
+
+  /**
+   * Resume a held call
+   */
+  public async resume(callSid: string): Promise<CallResponse<Call>> {
+    if (!this.activeConnection) return createErrorResult("No active call to resume.");
+    if (!callSid) return createErrorResult("Please provide callSid.");
+
+    try {
+      const payload: ResumeCallPayload = { callSid, conferenceName: this.conferenceName };
+      await axios.post(`${this.serverUrl}/outgoingCall.unhold`, payload);
+      console.info("[resume] Call resumed successfully.");
+      return createSuccessResult("Call resumed successfully.", this.activeConnection);
+    } catch (error: unknown) {
+      handleAxiosError(error, this.onError, "Failed to resume call");
+      const errMessage = error instanceof Error ? error.message : String(error);
+      return createErrorResult(`Failed to resume call: ${errMessage}`);
+    }
+  }
+
+  /**
+   * Hold active call and add a new participant
+   */
+  public async holdAndAddParticipant(callSid: string, newParticipantNo: string): Promise<HoldAndAddResult | CallResponse> {
+    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: HoldPayload = { conferenceName: this.conferenceName, callSid, waitUrl: this.waitUrl };
+      const holdRes = await axios.post(`${this.serverUrl}/outgoingCall.hold`, holdPayload);
+
+      const addPayload: AddParticipantPayload = { conferenceName: this.conferenceName, newParticipantNo };
+      const addRes = await axios.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: unknown) {
+      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}`);
+    }
+  }
+
+  /**
+   * Fetch conference details
+   */
+  public async getConferenceId(): Promise<GetConferenceResult | CallResponse<TwilioConference>> {
+    if (!this.activeConnection) return createErrorResult("No active call.");
+
+    const payload: GetConferencePayload = { conferenceName: this.conferenceName };
+
+    try {
+      const res = await axios.post(`${this.serverUrl}/outgoingCall.getConferenceId`, payload);
+
+      if (res?.data?.result?.data) {
+        const confDetails: TwilioConference = {
+          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: unknown) {
+      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}`);
+    }
+  }
+
+  /**
+   * Get participants of a conference
+   */
+  public async getParticipants(conferenceSid: string): Promise<GetParticipantsResult | CallResponse<TwilioConferenceParticipant[]>> {
+    if (!this.activeConnection) return createErrorResult("No active call.");
+    if (!conferenceSid) return createErrorResult("Please provide conferenceSid.");
+
+    try {
+      const payload: GetParticipantsPayload = { conferenceSid };
+      const res = await axios.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: unknown) {
+      handleAxiosError(error, this.onError, "Failed to get participants");
+      const errMessage = error instanceof Error ? error.message : String(error);
+      return createErrorResult(`Failed to get participants: ${errMessage}`);
+    }
+  }
+
+  /**
+   * Remove a participant from a conference
+   */
+  public async removeParticipant(conferenceSid: string, callSid: string): Promise<RemoveParticipantResult | CallResponse> {
+    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: RemoveParticipantPayload = { callSid, conferenceSid };
+      const res = await axios.post(`${this.serverUrl}/outgoingCall.removeParticipant`, payload);
+      console.info("[removeParticipant] Participant removed successfully.");
+      return createSuccessResult("Participant removed successfully.", res.data);
+    } catch (error: unknown) {
+      handleAxiosError(error, this.onError, "Failed to remove participant");
+      const errMessage = error instanceof Error ? error.message : String(error);
+      return createErrorResult(`Failed to remove participant: ${errMessage}`);
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+  {"compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,25 @@
+import { defineConfig } from "tsup";
+
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["cjs", "esm"],   // ✅ build both CommonJS and ES modules
+  dts: true,                // ✅ generate type declarations
+  sourcemap: true,
+  clean: true,
+  outDir: "dist",
+  splitting: false,         // disable code splitting for CJS compat
+  minify: false             // optional
+});
+
+// import { defineConfig } from "tsup";
+
+// export default defineConfig({
+//   entry: ["src/ZyraTwilioWrapper.ts"],
+//   format: ["esm", "cjs"],
+//   dts: true, // generate .d.ts types
+//   sourcemap: true,
+//   clean: true,
+//   minify: false,
+//   external: ["@twilio/voice-sdk"],
+// });