@ipcom/asterisk-ari 0.0.24 → 0.0.26

package/dist/cjs/index.cjs

@@ -582,6 +582,7 @@ __export(src_exports, {
   Applications: () => Applications,
   AriClient: () => AriClient,
   Asterisk: () => Asterisk,
+  Bridges: () => Bridges,
   Channels: () => Channels,
   Endpoints: () => Endpoints,
   Playbacks: () => Playbacks,
@@ -590,6 +591,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/ari-client/ariClient.ts
+var import_events3 = require("events");
 var import_exponential_backoff = __toESM(require_backoff(), 1);
 
 // src/ari-client/baseClient.ts
@@ -764,6 +766,95 @@ var Asterisk = class {
   }
 };
 
+// src/ari-client/resources/bridges.ts
+var Bridges = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Lists all active bridges.
+   */
+  async list() {
+    return this.client.get("/bridges");
+  }
+  /**
+   * Creates a new bridge.
+   */
+  async createBridge(request) {
+    return this.client.post("/bridges", request);
+  }
+  /**
+   * Retrieves details of a specific bridge.
+   */
+  async getDetails(bridgeId) {
+    return this.client.get(`/bridges/${bridgeId}`);
+  }
+  /**
+   * Destroys (deletes) a specific bridge.
+   */
+  async destroy(bridgeId) {
+    return this.client.delete(`/bridges/${bridgeId}`);
+  }
+  /**
+   * Adds a channel or multiple channels to a bridge.
+   */
+  async addChannels(bridgeId, request) {
+    const queryParams = new URLSearchParams({
+      channel: Array.isArray(request.channel) ? request.channel.join(",") : request.channel,
+      ...request.role && { role: request.role }
+    }).toString();
+    await this.client.post(
+      `/bridges/${bridgeId}/addChannel?${queryParams}`
+    );
+  }
+  /**
+   * Removes a channel or multiple channels from a bridge.
+   */
+  async removeChannels(bridgeId, request) {
+    const queryParams = new URLSearchParams({
+      channel: Array.isArray(request.channel) ? request.channel.join(",") : request.channel
+    }).toString();
+    await this.client.post(
+      `/bridges/${bridgeId}/removeChannel?${queryParams}`
+    );
+  }
+  /**
+   * Plays media to a bridge.
+   */
+  async playMedia(bridgeId, request) {
+    const queryParams = new URLSearchParams({
+      ...request.lang && { lang: request.lang },
+      ...request.offsetms && { offsetms: request.offsetms.toString() },
+      ...request.skipms && { skipms: request.skipms.toString() },
+      ...request.playbackId && { playbackId: request.playbackId }
+    }).toString();
+    return this.client.post(
+      `/bridges/${bridgeId}/play?${queryParams}`,
+      { media: request.media }
+    );
+  }
+  /**
+   * Stops media playback on a bridge.
+   */
+  async stopPlayback(bridgeId, playbackId) {
+    await this.client.delete(`/bridges/${bridgeId}/play/${playbackId}`);
+  }
+  /**
+   * Sets the video source for a bridge.
+   */
+  async setVideoSource(bridgeId, channelId) {
+    await this.client.post(
+      `/bridges/${bridgeId}/videoSource?channelId=${encodeURIComponent(channelId)}`
+    );
+  }
+  /**
+   * Clears the video source for a bridge.
+   */
+  async clearVideoSource(bridgeId) {
+    await this.client.delete(`/bridges/${bridgeId}/videoSource`);
+  }
+};
+
 // src/ari-client/resources/channels.ts
 function toQueryParams2(options) {
   return new URLSearchParams(
@@ -1111,8 +1202,10 @@ var Endpoints = class {
 };
 
 // src/ari-client/resources/playbacks.ts
-var Playbacks = class {
+var import_events = require("events");
+var Playbacks = class extends import_events.EventEmitter {
   constructor(client) {
+    super();
     this.client = client;
   }
   /**
@@ -1125,17 +1218,22 @@ var Playbacks = class {
     return this.client.get(`/playbacks/${playbackId}`);
   }
   /**
-   * Controls a specific playback (e.g., pause, resume, rewind, forward, stop).
+   * Controls a specific playback by performing various operations such as pause, resume, restart, reverse, forward, or stop.
    *
    * @param playbackId - The unique identifier of the playback to control.
-   * @param controlRequest - The PlaybackControlRequest containing the control operation.
+   * @param operation - The operation to perform on the playback. Possible values are:
+   *                    - "pause": Pauses the playback.
+   *                    - "unpause": Resumes a paused playback.
+   *                    - "restart": Restarts the playback from the beginning.
+   *                    - "reverse": Reverses the playback direction.
+   *                    - "forward": Moves the playback forward.
+   *                    - "stop": Stops the playback.
    * @returns A promise that resolves when the control operation is successfully executed.
    */
-  async control(playbackId, controlRequest) {
-    await this.client.post(
-      `/playbacks/${playbackId}/control`,
-      controlRequest
-    );
+  async control(playbackId, operation) {
+    await this.client.post(`/playbacks/${playbackId}/control`, {
+      operation
+    });
   }
   /**
    * Stops a specific playback.
@@ -1146,6 +1244,50 @@ var Playbacks = class {
   async stop(playbackId) {
     await this.client.post(`/playbacks/${playbackId}/stop`);
   }
+  /**
+   * Registers a listener for playback events.
+   * The listener is triggered for events such as "PlaybackFinished".
+   *
+   * @param eventType - The type of event to listen for.
+   * @param playbackId - The ID of the playback to associate with this listener.
+   * @param callback - The callback function to execute when the event occurs.
+   */
+  registerListener(eventType, playbackId, callback) {
+    this.on(`${eventType}:${playbackId}`, callback);
+  }
+  /**
+   * Unregisters a listener for playback events.
+   *
+   * @param eventType - The type of event to stop listening for.
+   * @param playbackId - The ID of the playback associated with the listener.
+   * @param callback - The callback function to remove.
+   */
+  unregisterListener(eventType, playbackId, callback) {
+    this.off(`${eventType}:${playbackId}`, callback);
+  }
+  /**
+   * Checks if a listener is already registered for a specific event and playback.
+   *
+   * @param eventType - The type of event to check.
+   * @param playbackId - The playback ID associated with the listener.
+   * @returns True if a listener is already registered, false otherwise.
+   */
+  isListenerRegistered(eventType, playbackId) {
+    return this.listenerCount(`${eventType}:${playbackId}`) > 0;
+  }
+  /**
+   * Emits playback events received via WebSocket.
+   * This method should be called by the WebSocket client when playback events occur.
+   *
+   * @param eventType - The type of the WebSocket event.
+   * @param data - The data associated with the event.
+   */
+  emitPlaybackEvent(eventType, data) {
+    if ("playbackId" in data) {
+      this.emit(`${eventType}:${data.playbackId}`, data);
+    }
+    this.emit(eventType, data);
+  }
 };
 
 // src/ari-client/resources/sounds.ts
@@ -1180,16 +1322,25 @@ var Sounds = class {
 };
 
 // src/ari-client/websocketClient.ts
+var import_events2 = require("events");
 var import_ws = __toESM(require("ws"), 1);
-var WebSocketClient = class {
-  // Para evitar reconexões paralelas
+var WebSocketClient = class extends import_events2.EventEmitter {
+  /**
+   * Creates a new WebSocketClient instance.
+   * @param url - The WebSocket server URL to connect to.
+   */
   constructor(url) {
+    super();
     this.url = url;
   }
   ws = null;
   isClosedManually = false;
-  // Para evitar reconexões automáticas quando fechado manualmente
   isReconnecting = false;
+  /**
+   * Establishes a connection to the WebSocket server.
+   * @returns A Promise that resolves when the connection is established, or rejects if an error occurs.
+   * @throws Will throw an error if the connection fails.
+   */
   async connect() {
     if (this.isReconnecting) return;
     return new Promise((resolve, reject) => {
@@ -1207,47 +1358,70 @@ var WebSocketClient = class {
       this.ws.on("close", (code, reason) => {
         console.warn(`WebSocket desconectado: ${code} - ${reason}`);
         this.isReconnecting = false;
+        this.emit("close", { code, reason });
+      });
+      this.ws.on("message", (rawData) => {
+        this.handleMessage(rawData);
       });
     });
   }
-  async reconnect() {
-    if (this.isClosedManually || this.isReconnecting) return;
-    console.log("Tentando reconectar ao WebSocket...");
-    this.isReconnecting = true;
-    try {
-      await this.connect();
-      console.log("Reconex\xE3o bem-sucedida.");
-    } catch (err) {
-      console.error("Erro ao tentar reconectar:", err);
-    } finally {
-      this.isReconnecting = false;
-    }
-  }
+  /**
+   * Checks if the WebSocket connection is currently open.
+   * @returns True if the connection is open, false otherwise.
+   */
   isConnected() {
     return this.ws?.readyState === import_ws.default.OPEN;
   }
+  /**
+   * Adds a listener for WebSocket events.
+   * @param event - The event type to listen for.
+   * @param callback - The function to call when the event occurs.
+   * @returns The WebSocketClient instance for chaining.
+   */
   on(event, callback) {
-    if (!this.ws || this.ws.readyState !== import_ws.default.OPEN) {
-      throw new Error("WebSocket n\xE3o est\xE1 conectado.");
-    }
-    if (event === "message") {
-      this.ws.on(event, (rawData) => {
-        try {
-          const decodedData = JSON.parse(rawData.toString());
-          if (decodedData?.type) {
-            const matchedEvent = decodedData;
-            callback(matchedEvent);
-          } else {
-            console.warn("Mensagem sem tipo:", decodedData);
-          }
-        } catch (err) {
-          console.error("Erro ao decodificar mensagem do WebSocket:", err);
-        }
-      });
-    } else {
-      this.ws.on(event, callback);
+    super.on(event, callback);
+    return this;
+  }
+  /**
+   * Removes a specific listener from a WebSocket event.
+   * @param event - The event type to remove the listener from.
+   * @param callback - The function to remove from the event listeners.
+   * @returns The WebSocketClient instance for chaining.
+   */
+  off(event, callback) {
+    super.off(event, callback);
+    return this;
+  }
+  /**
+   * Removes all listeners for a specific event, or all events if no event is specified.
+   * @param event - Optional. The event to remove all listeners from.
+   * @returns The WebSocketClient instance for chaining.
+   */
+  removeAllListeners(event) {
+    super.removeAllListeners(event);
+    return this;
+  }
+  /**
+   * Handles incoming WebSocket messages.
+   * @param rawData - The raw data received from the WebSocket.
+   */
+  handleMessage(rawData) {
+    try {
+      const decodedData = JSON.parse(rawData.toString());
+      if (decodedData?.type) {
+        this.emit(decodedData.type, decodedData);
+      } else {
+        console.warn("Mensagem recebida sem tipo:", decodedData);
+      }
+    } catch (err) {
+      console.error("Erro ao decodificar mensagem do WebSocket:", err);
     }
   }
+  /**
+   * Sends data through the WebSocket connection.
+   * @param data - The data to send.
+   * @throws Will throw an error if the WebSocket is not connected.
+   */
   send(data) {
     if (!this.ws || this.ws.readyState !== import_ws.default.OPEN) {
       throw new Error("WebSocket n\xE3o est\xE1 conectado.");
@@ -1258,6 +1432,9 @@ var WebSocketClient = class {
       }
     });
   }
+  /**
+   * Closes the WebSocket connection manually.
+   */
   close() {
     if (this.ws) {
       this.isClosedManually = true;
@@ -1281,21 +1458,29 @@ var AriClient = class {
     this.playbacks = new Playbacks(this.baseClient);
     this.sounds = new Sounds(this.baseClient);
     this.asterisk = new Asterisk(this.baseClient);
+    this.bridges = new Bridges(this.baseClient);
   }
   wsClient = null;
   baseClient;
   isReconnecting = false;
+  eventEmitter = new import_events3.EventEmitter();
   channels;
   endpoints;
   applications;
   playbacks;
   sounds;
   asterisk;
+  bridges;
   /**
    * Connects to the ARI WebSocket for a specific application.
+   * This function establishes a WebSocket connection to the Asterisk ARI, sets up event listeners,
+   * and ensures the application is registered. It uses an exponential backoff strategy for connection attempts.
    *
-   * @param app - The application name to connect to.
-   * @returns {Promise<void>} Resolves when the WebSocket connects successfully.
+   * @param app - The name of the application to connect to. This is required and used to identify the application in ARI.
+   * @param subscribedEvents - Optional array of WebSocketEventType to subscribe to specific events.
+   *                           If not provided or empty, it subscribes to all events.
+   * @returns A Promise that resolves when the WebSocket connection is successfully established and the application is registered.
+   * @throws Error if the 'app' parameter is not provided, or if connection attempts fail after multiple retries.
    */
   async connectWebSocket(app, subscribedEvents) {
     if (!app) {
@@ -1323,6 +1508,11 @@ var AriClient = class {
         return !this.wsClient?.isConnected();
       }
     };
+    if (this.wsClient?.isConnected()) {
+      console.log("WebSocket j\xE1 conectado. Removendo listeners antigos...");
+      this.wsClient.removeAllListeners();
+      this.wsClient.close();
+    }
     this.wsClient = new WebSocketClient(wsUrl);
     try {
       await (0, import_exponential_backoff.backOff)(async () => {
@@ -1330,6 +1520,7 @@ var AriClient = class {
           throw new Error("WebSocketClient instance is null.");
         }
         await this.wsClient.connect();
+        this.integrateWebSocketEvents();
         console.log(`WebSocket conectado para o app: ${app}`);
         await this.ensureAppRegistered(app);
       }, backoffOptions);
@@ -1343,6 +1534,103 @@ var AriClient = class {
       this.isReconnecting = false;
     }
   }
+  /**
+   * Integrates WebSocket events with playback listeners.
+   */
+  integrateWebSocketEvents() {
+    if (!this.wsClient) {
+      throw new Error("WebSocket client n\xE3o est\xE1 conectado.");
+    }
+    const eventHandlers = {
+      PlaybackFinished: (data) => {
+        if ("playbackId" in data) {
+          this.playbacks.emitPlaybackEvent("PlaybackFinished", data);
+        }
+        this.emitGlobalEvent(data);
+      },
+      ChannelStateChange: (data) => {
+        if ("channel" in data) {
+          console.log("Estado do canal alterado:", data.channel);
+        }
+        this.emitGlobalEvent(data);
+      },
+      BridgeDestroyed: (data) => {
+        if ("bridge" in data) {
+          console.log("Bridge destru\xEDda:", data.bridge);
+        }
+        this.emitGlobalEvent(data);
+      },
+      // Adicione mais eventos conforme necessário
+      // Exemplo:
+      ChannelDtmfReceived: (data) => {
+        if ("channel" in data) {
+          console.log("DTMF recebido no canal:", data.channel);
+        }
+        this.emitGlobalEvent(data);
+      }
+    };
+    for (const [eventType, handler] of Object.entries(eventHandlers)) {
+      if (handler) {
+        this.wsClient.on(eventType, handler);
+      }
+    }
+    console.log("Todos os eventos do WebSocket foram registrados.");
+  }
+  /**
+   * Registra um listener para eventos globais.
+   * @param callback - A função a ser executada quando um evento global for recebido.
+   */
+  onGlobalEvent(callback) {
+    this.eventEmitter.on("globalEvent", callback);
+  }
+  /**
+   * Remove um listener para eventos globais.
+   * @param callback - A função a ser removida dos eventos globais.
+   */
+  offGlobalEvent(callback) {
+    this.eventEmitter.off("globalEvent", callback);
+  }
+  /**
+   * Emite um evento global.
+   * @param data - Os dados do evento a serem emitidos.
+   */
+  emitGlobalEvent(data) {
+    this.eventEmitter.emit("globalEvent", data);
+  }
+  /**
+   * Unregisters a listener for playback events.
+   *
+   * This method removes a specific listener registered for a playback event type,
+   * ensuring that no further notifications are sent to the callback function.
+   *
+   * @param eventType - The type of event to stop listening for.
+   * @param playbackId - The unique ID of the playback associated with the listener.
+   * @param callback - The callback function to remove from the listener.
+   */
+  unregisterPlaybackListener(eventType, playbackId, callback) {
+    this.playbacks.unregisterListener(eventType, playbackId, callback);
+  }
+  /**
+   * Registers a listener for playback events.
+   * The listener is triggered for events such as "PlaybackFinished".
+   *
+   * @param eventType - The type of event to listen for.
+   * @param playbackId - The ID of the playback to associate with this listener.
+   * @param callback - The callback function to execute when the event occurs.
+   */
+  registerPlaybackListener(eventType, playbackId, callback) {
+    this.playbacks.registerListener(eventType, playbackId, callback);
+  }
+  /**
+   * Checks if a listener is already registered for a specific event and playback.
+   *
+   * @param eventType - The type of event to check.
+   * @param playbackId - The playback ID associated with the listener.
+   * @returns True if a listener is already registered, false otherwise.
+   */
+  isPlaybackListenerRegistered(eventType, playbackId) {
+    return this.playbacks.isListenerRegistered(eventType, playbackId);
+  }
   /**
    * Ensures the ARI application is registered.
    *
@@ -1374,23 +1662,72 @@ var AriClient = class {
     return this.wsClient ? this.wsClient.isConnected() : false;
   }
   /**
-   * Registers a callback function for WebSocket events.
-   * This method allows you to listen for and respond to WebSocket messages
-   * and process specific event types.
+   * Registers a listener for WebSocket events.
+   *
+   * This function allows you to attach a callback function to a specific WebSocket event type.
+   * The callback will be executed whenever an event of the specified type is received.
+   *
+   * @template T - The type of WebSocket event, extending WebSocketEvent["type"].
+   * @param {T} event - The type of WebSocket event to listen for.
+   * @param {(data: Extract<WebSocketEvent, { type: T }>) => void} callback - The function to be called when the event is received.
+   *        The callback receives the event data as its parameter.
+   * @throws {Error} Throws an error if the WebSocket client is not connected when this method is called.
+   * @returns {void} This function doesn't return a value.
+   */
+  onWebSocketEvent(event, callback) {
+    if (!this.wsClient) {
+      throw new Error("WebSocket n\xE3o est\xE1 conectado.");
+    }
+    this.wsClient.on(event, callback);
+  }
+  /**
+   * Removes a specific listener for WebSocket events.
    *
-   * @param callback - The callback function to execute when a WebSocket message is received.
-   *                   The function will receive the parsed event data as its parameter.
-   * @throws {Error} Throws an error if the WebSocket is not connected when trying to register the event.
-   * @returns {void}
+   * This function unregisters a previously registered callback function for a specific WebSocket event type.
+   * It's useful for removing event handlers when they are no longer needed or for cleaning up resources.
+   *
+   * @template T - The type of WebSocket event, extending WebSocketEvent["type"].
+   * @param {T} event - The type of WebSocket event to remove the listener from.
+   * @param {(data: Extract<WebSocketEvent, { type: T }>) => void} callback - The callback function to be removed.
+   *        This should be the same function reference that was used when adding the event listener.
+   * @throws {Error} Throws an error if the WebSocket client is not connected when this method is called.
+   * @returns {void} This function doesn't return a value.
+   */
+  offWebSocketEvent(event, callback) {
+    if (!this.wsClient) {
+      throw new Error("WebSocket n\xE3o est\xE1 conectado.");
+    }
+    this.wsClient.off(event, callback);
+  }
+  /**
+   * Removes all listeners for a specific WebSocket event type.
+   *
+   * This function removes all event listeners that have been registered for a particular
+   * WebSocket event type. It's useful for cleaning up event listeners when they are no
+   * longer needed or before re-registering new listeners.
+   *
+   * @param event - The type of WebSocket event for which all listeners should be removed.
+   *                This should be a string identifying the event type (e.g., 'message', 'close', etc.).
+   *
+   * @throws {Error} Throws an error if the WebSocket client is not connected when this method is called.
+   *
+   * @returns {void} This function doesn't return a value.
    */
-  onWebSocketEvent(callback) {
+  removeAllWebSocketListeners(event) {
     if (!this.wsClient) {
-      throw new Error("WebSocket is not connected.");
+      throw new Error("WebSocket n\xE3o est\xE1 conectado.");
     }
-    this.wsClient.on("message", callback);
+    this.wsClient.removeAllListeners(event);
   }
   /**
-   * Closes the WebSocket connection.
+   * Closes the WebSocket connection and removes all associated listeners.
+   *
+   * This function terminates the active WebSocket connection if one exists,
+   * and cleans up by removing all event listeners attached to it. After calling
+   * this function, the WebSocket client will be set to null, effectively
+   * ending the connection and preparing for potential future connections.
+   *
+   * @returns {void} This function doesn't return a value.
    */
   closeWebSocket() {
     if (this.wsClient) {
@@ -1802,13 +2139,22 @@ var AriClient = class {
   }
   /**
    * Controls a specific playback in the Asterisk server.
+   * This function allows manipulation of an ongoing playback, such as pausing, resuming, or skipping.
    *
    * @param playbackId - The unique identifier of the playback to control.
+   *                     This should be a string that uniquely identifies the playback in the Asterisk system.
    * @param controlRequest - An object containing the control operation details.
+   *                         This object should conform to the PlaybackControlRequest interface,
+   *                         which includes an 'operation' property specifying the control action to perform.
    * @returns A Promise that resolves when the control operation is successfully executed.
+   *          The promise resolves to void, indicating no specific return value.
+   *          If an error occurs during the operation, the promise will be rejected with an error object.
+   * @throws Will throw an error if the playback control operation fails, e.g., if the playback doesn't exist
+   *         or the requested operation is invalid.
    */
   async controlPlayback(playbackId, controlRequest) {
-    return this.playbacks.control(playbackId, controlRequest);
+    const { operation } = controlRequest;
+    return this.playbacks.control(playbackId, operation);
   }
   /**
    * Stops a specific playback in the Asterisk server.
@@ -1923,6 +2269,7 @@ var AriClient = class {
   Applications,
   AriClient,
   Asterisk,
+  Bridges,
   Channels,
   Endpoints,
   Playbacks,