@experteam-mx/ngx-services 20.8.6 → 20.8.9

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

@@ -5582,16 +5582,80 @@ var DocumentStatusCode;
     DocumentStatusCode[DocumentStatusCode["WITH_ERRORS"] = 3] = "WITH_ERRORS";
 })(DocumentStatusCode || (DocumentStatusCode = {}));
 
+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);
         });
     }
     /**
@@ -5614,13 +5678,16 @@ class WebSocketsService {
      * @throws {Error} If the subscription fails after the maximum number of retry attempts.
      */
     async channelSub(channelName) {
+        const pusher = await this.ensureConnected();
+        this.refreshChannelAuthHeader();
         const attempts = 3;
         for (let attempt = 0; attempt <= attempts; attempt++) {
-            const channel = this.pusher?.channel(channelName);
+            const channel = pusher.channel(channelName);
             if (channel?.subscribed) {
                 return channel;
             }
-            this.pusher?.subscribe(channelName);
+            this.refreshChannelAuthHeader();
+            pusher.subscribe(channelName);
             if (attempt < attempts) {
                 await this.wait();
             }
@@ -5637,13 +5704,22 @@ class WebSocketsService {
      */
     eventBind(channel, event) {
         return new Observable((subscriber) => {
-            if (channel?.name) {
-                channel.bind(event, (data) => subscriber.next(data));
-            }
-            else {
-                this.pusher?.subscribe(channel)
-                    .bind(event, (data) => subscriber.next(data));
-            }
+            void (async () => {
+                try {
+                    const pusher = await this.ensureConnected();
+                    this.refreshChannelAuthHeader();
+                    if (channel?.name) {
+                        channel.bind(event, (data) => subscriber.next(data));
+                    }
+                    else {
+                        pusher.subscribe(channel)
+                            .bind(event, (data) => subscriber.next(data));
+                    }
+                }
+                catch (error) {
+                    subscriber.error(error);
+                }
+            })();
         });
     }
     /**
@@ -5657,23 +5733,33 @@ 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;
+    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;
+        }
+    }
+    refreshChannelAuthHeader() {
+        const token = this.getAuthToken?.() ?? null;
+        if (token) {
+            this.channelAuthHeaders['Authorization'] = `Bearer ${token}`;
+        }
+        else {
+            delete this.channelAuthHeaders['Authorization'];
+        }
     }
     async wait() {
         const waitTime = 3 * 1000;
@@ -5687,13 +5773,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.25", 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);
@@ -5706,13 +5791,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
@@ -5724,14 +5809,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 = '';