@experteam-mx/ngx-services 20.8.8 → 20.8.10

package/fesm2022/experteam-mx-ngx-services.mjs

@@ -5582,11 +5582,14 @@ var DocumentStatusCode;
     DocumentStatusCode[DocumentStatusCode["WITH_ERRORS"] = 3] = "WITH_ERRORS";
 })(DocumentStatusCode || (DocumentStatusCode = {}));
 
+const SOCKETS_AUTH_PATH = '/sockets/auth';
 class WebSocketsService {
     pusher = null;
     appKey = null;
     connectPromise = null;
     environments = inject(ENVIRONMENT_TOKEN);
+    getAuthToken = null;
+    channelAuthHeaders = {};
     /**
      * Stores the Pusher/Soketi application key without opening a connection.
      * The first `channelSub` / `eventBind` opens Pusher via `ensureConnected`.
@@ -5596,6 +5599,15 @@ class WebSocketsService {
     setAppKey(appKey) {
         this.appKey = appKey;
     }
+    /**
+     * Registers a live token provider used when authorizing private/presence channels.
+     * The provider is called at subscribe/authorize time; the token is not snapshotted here.
+     *
+     * @param {() => string | null} getToken - Returns the current session token, or null.
+     */
+    setAuthTokenProvider(getToken) {
+        this.getAuthToken = getToken;
+    }
     /**
      * Connects to Pusher using the given app key and env `sockets` url/port/debug.
      * No-ops if already connected with the same key; reconnects if the key changed.
@@ -5618,13 +5630,27 @@ class WebSocketsService {
                 this.pusher.disconnect();
                 this.pusher = null;
             }
-            const pusher = new Pusher(appKey, {
+            const options = {
                 wsHost: sockets.url,
                 wsPort: sockets.port,
                 enabledTransports: ['wss', 'ws'],
                 forceTLS: false,
                 enableStats: false,
-            });
+            };
+            const { apiSecurityUrl } = this.environments;
+            if (apiSecurityUrl) {
+                this.refreshChannelAuthHeader();
+                options.channelAuthorization = {
+                    transport: 'ajax',
+                    endpoint: `${apiSecurityUrl}${SOCKETS_AUTH_PATH}`,
+                    headers: this.channelAuthHeaders,
+                    headersProvider: () => {
+                        this.refreshChannelAuthHeader();
+                        return this.channelAuthHeaders;
+                    },
+                };
+            }
+            const pusher = new Pusher(appKey, options);
             if (sockets.debug) {
                 Pusher.logToConsole = true;
             }
@@ -5645,26 +5671,40 @@ class WebSocketsService {
         return channel.trigger(`client-${eventName}`, data);
     }
     /**
-     * Subscribes to a specified channel, retrying multiple times upon failure.
+     * Subscribes to a specified channel and resolves when Pusher reports success.
      *
      * @param {string} channelName - The name of the channel to be subscribed to.
      * @return {Promise<Channel>} A promise that resolves to the subscribed channel object if successful.
-     * @throws {Error} If the subscription fails after the maximum number of retry attempts.
+     * @throws {Error} If the subscription fails.
      */
     async channelSub(channelName) {
         const pusher = await this.ensureConnected();
-        const attempts = 3;
-        for (let attempt = 0; attempt <= attempts; attempt++) {
-            const channel = pusher.channel(channelName);
-            if (channel?.subscribed) {
-                return channel;
-            }
-            pusher.subscribe(channelName);
-            if (attempt < attempts) {
-                await this.wait();
-            }
+        this.refreshChannelAuthHeader();
+        const existing = pusher.channel(channelName);
+        if (existing?.subscribed) {
+            return existing;
         }
-        throw new Error(`Failed to subscribe to channel "${channelName}" after ${attempts} attempts.`);
+        const channel = pusher.subscribe(channelName);
+        if (channel.subscribed) {
+            return channel;
+        }
+        await new Promise((resolve, reject) => {
+            const onSuccess = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = () => {
+                cleanup();
+                reject(new Error(`Failed to subscribe to channel "${channelName}".`));
+            };
+            const cleanup = () => {
+                channel.unbind('pusher:subscription_succeeded', onSuccess);
+                channel.unbind('pusher:subscription_error', onError);
+            };
+            channel.bind('pusher:subscription_succeeded', onSuccess);
+            channel.bind('pusher:subscription_error', onError);
+        });
+        return channel;
     }
     /**
      * Binds an event listener to a specified event on a given channel using Pusher or a Channel object,
@@ -5676,16 +5716,16 @@ class WebSocketsService {
      */
     eventBind(channel, event) {
         return new Observable((subscriber) => {
+            if (channel?.name) {
+                channel.bind(event, (data) => subscriber.next(data));
+                return;
+            }
             void (async () => {
                 try {
                     const pusher = await this.ensureConnected();
-                    if (channel?.name) {
-                        channel.bind(event, (data) => subscriber.next(data));
-                    }
-                    else {
-                        pusher.subscribe(channel)
-                            .bind(event, (data) => subscriber.next(data));
-                    }
+                    this.refreshChannelAuthHeader();
+                    pusher.subscribe(channel)
+                        .bind(event, (data) => subscriber.next(data));
                 }
                 catch (error) {
                     subscriber.error(error);
@@ -5704,6 +5744,14 @@ class WebSocketsService {
     eventUnbind(channel, event) {
         return new Observable((subscriber) => channel.unbind(event, (data) => subscriber.next(data)));
     }
+    /**
+     * Unsubscribes from a channel by name.
+     *
+     * @param {string} channelName - The channel name previously passed to subscribe.
+     */
+    unsubscribe(channelName) {
+        this.pusher?.unsubscribe(channelName);
+    }
     async ensureConnected() {
         if (this.pusher)
             return this.pusher;
@@ -5723,9 +5771,14 @@ class WebSocketsService {
             throw error;
         }
     }
-    async wait() {
-        const waitTime = 3 * 1000;
-        return new Promise((resolve) => setTimeout(resolve, waitTime));
+    refreshChannelAuthHeader() {
+        const token = this.getAuthToken?.() ?? null;
+        if (token) {
+            this.channelAuthHeaders['Authorization'] = `Bearer ${token}`;
+        }
+        else {
+            delete this.channelAuthHeaders['Authorization'];
+        }
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: WebSocketsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.25", ngImport: i0, type: WebSocketsService, providedIn: 'root' });