@experteam-mx/ngx-services 20.9.10 → 20.9.11

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

@@ -5912,16 +5912,80 @@ var CustomerRoleType;
     CustomerRoleType["EXPORTER"] = "EP";
 })(CustomerRoleType || (CustomerRoleType = {}));
 
+const SOCKETS_AUTH_PATH = '/sockets/auth';
 class WebSocketsService {
-    pusher;
+    pusher = null;
+    appKey = null;
+    connectPromise = null;
     environments = inject(ENVIRONMENT_TOKEN);
-    constructor() {
-        this.pusher = null;
-        this.connect()
-            .then((pusher) => {
-            if (!pusher)
-                return;
+    getAuthToken = null;
+    channelAuthHeaders = {};
+    /**
+     * Stores the Pusher/Soketi application key without opening a connection.
+     * The first `channelSub` / `eventBind` opens Pusher via `ensureConnected`.
+     *
+     * @param {string} appKey - The Pusher/Soketi application key.
+     */
+    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.
+     * Resolves false when `sockets` is missing from the environment.
+     * Apps should store the key with `setAppKey` and let subscribe open the client.
+     *
+     * @param {string} appKey - The Pusher/Soketi application key.
+     * @return {Promise<Pusher | false>} The Pusher instance, or false when sockets are not configured.
+     */
+    connect(appKey) {
+        this.setAppKey(appKey);
+        return new Promise((resolve) => {
+            if (this.pusher && this.appKey === appKey) {
+                return resolve(this.pusher);
+            }
+            const { sockets } = this.environments;
+            if (!sockets)
+                return resolve(false);
+            if (this.pusher) {
+                this.pusher.disconnect();
+                this.pusher = null;
+            }
+            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;
+            }
             this.pusher = pusher;
+            return resolve(pusher);
         });
     }
     /**
@@ -5937,25 +6001,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 attempts = 3;
-        for (let attempt = 0; attempt <= attempts; attempt++) {
-            const channel = this.pusher?.channel(channelName);
-            if (channel?.subscribed) {
-                return channel;
-            }
-            this.pusher?.subscribe(channelName);
-            if (attempt < attempts) {
-                await this.wait();
-            }
+        const pusher = await this.ensureConnected();
+        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,
@@ -5969,11 +6048,19 @@ class WebSocketsService {
         return new Observable((subscriber) => {
             if (channel?.name) {
                 channel.bind(event, (data) => subscriber.next(data));
+                return;
             }
-            else {
-                this.pusher?.subscribe(channel)
-                    .bind(event, (data) => subscriber.next(data));
-            }
+            void (async () => {
+                try {
+                    const pusher = await this.ensureConnected();
+                    this.refreshChannelAuthHeader();
+                    pusher.subscribe(channel)
+                        .bind(event, (data) => subscriber.next(data));
+                }
+                catch (error) {
+                    subscriber.error(error);
+                }
+            })();
         });
     }
     /**
@@ -5987,27 +6074,41 @@ class WebSocketsService {
     eventUnbind(channel, event) {
         return new Observable((subscriber) => channel.unbind(event, (data) => subscriber.next(data)));
     }
-    connect() {
-        return new Promise((resolve) => {
-            const { sockets } = this.environments;
-            if (!sockets)
-                return resolve(false);
-            const pusher = new Pusher(sockets.app_key, {
-                wsHost: sockets.url,
-                wsPort: sockets.port,
-                enabledTransports: ['wss', 'ws'],
-                forceTLS: false,
-                enableStats: false,
-            });
-            if (sockets.debug) {
-                Pusher.logToConsole = true;
+    /**
+     * 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;
+        if (!this.appKey) {
+            throw new Error('The sockets connection is not established.');
+        }
+        this.connectPromise ??= this.connect(this.appKey);
+        try {
+            const pusher = await this.connectPromise;
+            if (!pusher) {
+                throw new Error('The sockets connection is not established.');
             }
-            return resolve(pusher);
-        });
+            return pusher;
+        }
+        catch (error) {
+            this.connectPromise = null;
+            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.27", ngImport: i0, type: WebSocketsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.27", ngImport: i0, type: WebSocketsService, providedIn: 'root' });
@@ -6017,13 +6118,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.27", ngImpo
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: () => [] });
+        }] });
 
 const AES_KEY_USAGES = ['encrypt', 'decrypt'];
 class CryptoService {
-    environments = inject(ENVIRONMENT_TOKEN);
-    async encryptAES(plaintext) {
-        const cryptoKey = await this.loadKey();
+    async encryptAES(plaintext, secretKey) {
+        const cryptoKey = await this.loadKey(secretKey);
         // Convert the plaintext in Uint8Array
         const encoder = new TextEncoder();
         const encoded = encoder.encode(plaintext);
@@ -6036,13 +6136,13 @@ class CryptoService {
         }, cryptoKey, encoded);
         return `${this.uint8ArrayToBase64(iv)}:${this.arrayBufferToBase64(ciphertext)}`;
     }
-    async decryptAES(payload) {
+    async decryptAES(payload, secretKey) {
         // Extract the Initialization Vector (IV), and the cypher text
         const [base64IV, base64Ciphertext] = payload.split(':');
         if (!base64IV || !base64Ciphertext) {
             throw new Error('The payload must contain the IV and the cipher text.');
         }
-        const cryptoKey = await this.loadKey();
+        const cryptoKey = await this.loadKey(secretKey);
         const iv = this.base64ToUint8Array(base64IV);
         const cipherText = this.base64ToArrayBuffer(base64Ciphertext);
         // Decrypt the cypher text
@@ -6054,14 +6154,12 @@ class CryptoService {
         const decoder = new TextDecoder();
         return decoder.decode(decrypted);
     }
-    async loadKey() {
-        if (!this.environments.secretKey) {
-            throw new Error('The secret key is not defined in the environment configuration.');
+    async loadKey(secretKey) {
+        if (!secretKey) {
+            throw new Error('The secret key is not defined.');
         }
-        // Decode the base64 key to Uint8Array
-        const rawKey = this.base64ToUint8Array(this.environments.secretKey);
-        // Import the key to API Crypto
-        return await crypto.subtle.importKey('raw', rawKey, { name: 'AES-GCM' }, true, AES_KEY_USAGES);
+        const rawKey = new TextEncoder().encode(secretKey);
+        return crypto.subtle.importKey('raw', rawKey, { name: 'AES-GCM' }, true, AES_KEY_USAGES);
     }
     uint8ArrayToBase64(data) {
         let binary = '';