npm - javonet-nodejs-sdk - Versions diffs - 2.6.0 → 2.6.1 - Mend

javonet-nodejs-sdk 2.6.0 → 2.6.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/core/webSocketClient/WebSocketClient.cjs CHANGED Viewed

@@ -19,7 +19,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var WebSocketClient_exports = {};
 __export(WebSocketClient_exports, {
   WebSocketClient: () => WebSocketClient,
-  clients: () => clients
+  clients: () => clients,
+  messageQueue: () => messageQueue,
+  processingQueues: () => processingQueues
 });
 module.exports = __toCommonJS(WebSocketClient_exports);
 var import_Runtime = require("../../utils/Runtime.cjs");
@@ -39,6 +41,8 @@ const WebSocketStateEvent = {
 };
 let WebSocket = null;
 const clients = {};
+const messageQueue = {};
+const processingQueues = {};
 class WebSocketClient {
   /**
    * @param {string} url
@@ -56,15 +60,57 @@ class WebSocketClient {
     return this.instance ? this.instance?.readyState === WebSocketStateEnum.OPEN : false;
   }
   /**
-   * Sends messageArray through websocket connection
+   * Sends messageArray through websocket connection with guaranteed order preservation
    * @async
    * @param {Int8Array} messageArray
    * @returns {Promise<Int8Array>}
    */
   send(messageArray) {
+    return new Promise((resolve, reject) => {
+      if (!messageQueue[this.url]) {
+        messageQueue[this.url] = [];
+      }
+      messageQueue[this.url].push({ resolve, reject, messageArray });
+      this._processMessage();
+    });
+  }
+  /**
+   * Processes message queue sequentially to maintain order
+   * @private
+   * @async
+   */
+  async _processMessage() {
+    if (processingQueues[this.url]) {
+      return;
+    }
+    processingQueues[this.url] = true;
+    try {
+      while (messageQueue[this.url] && messageQueue[this.url].length > 0) {
+        const item = messageQueue[this.url].shift();
+        if (!item) break;
+        const { resolve, reject, messageArray } = item;
+        try {
+          const response = await this._send(messageArray);
+          resolve(response);
+        } catch (error) {
+          reject(error);
+        }
+      }
+    } finally {
+      processingQueues[this.url] = false;
+    }
+  }
+  /**
+   * Sends a single message through websocket connection
+   * @private
+   * @async
+   * @param {Int8Array} messageArray
+   * @returns {Promise<Int8Array>}
+   */
+  _send(messageArray) {
     return new Promise((resolve, reject) => {
       const client = this.instance;
-      if (client) {
+      if (client && this.isConnected) {
         client.send(
           /** @type {any} */
           messageArray
@@ -78,8 +124,8 @@ class WebSocketClient {
         };
         client.on(WebSocketStateEvent.MESSAGE, messageHandler);
       } else {
-        this._connect().then((ws) => {
-          ws.send(
+        this._connect().then((client2) => {
+          client2.send(
             /** @type {any} */
             messageArray
           );
@@ -88,21 +134,28 @@ class WebSocketClient {
             if (this.isDisconnectedAfterMessage) {
               this.disconnect();
             }
-            ws.removeListener(WebSocketStateEvent.MESSAGE, messageHandler);
+            client2.removeListener(WebSocketStateEvent.MESSAGE, messageHandler);
           };
-          ws.on(WebSocketStateEvent.MESSAGE, messageHandler);
+          client2.on(WebSocketStateEvent.MESSAGE, messageHandler);
         }).catch(reject);
       }
     });
   }
   /**
-   * Disconnects the WebSocket by terminating the connection.
+   * Disconnects the WebSocket by terminating the connection and cleans up queues.
    */
   disconnect() {
     if (this.instance) {
       this.instance.close();
       delete clients[this.url];
     }
+    if (messageQueue[this.url]) {
+      messageQueue[this.url].forEach(({ reject }) => {
+        reject(new Error("WebSocket disconnected"));
+      });
+      delete messageQueue[this.url];
+    }
+    delete processingQueues[this.url];
   }
   /**
    * Connects to the WebSocket server.
@@ -144,5 +197,7 @@ class WebSocketClient {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   WebSocketClient,
-  clients
+  clients,
+  messageQueue,
+  processingQueues
 });

package/dist/core/webSocketClient/WebSocketClientBrowser.cjs CHANGED Viewed

@@ -19,7 +19,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var WebSocketClientBrowser_exports = {};
 __export(WebSocketClientBrowser_exports, {
   WebSocketClientBrowser: () => WebSocketClientBrowser,
-  clients: () => clients
+  clients: () => clients,
+  messageQueue: () => messageQueue,
+  processingQueues: () => processingQueues
 });
 module.exports = __toCommonJS(WebSocketClientBrowser_exports);
 var import_Runtime = require("../../utils/Runtime.cjs");
@@ -37,6 +39,8 @@ if ((0, import_Runtime.isBrowserRuntime)()) {
   WsClient = WebSocket;
 }
 const clients = {};
+const messageQueue = {};
+const processingQueues = {};
 class WebSocketClientBrowser {
   /**
    * @param {string} url
@@ -54,12 +58,54 @@ class WebSocketClientBrowser {
     return this.instance ? this.instance.readyState === WebSocket.OPEN : false;
   }
   /**
-   * Sends messageArray through websocket connection
+   * Sends messageArray through websocket connection with guaranteed order preservation
    * @async
    * @param {Int8Array} messageArray
    * @returns {Promise<Int8Array>}
    */
   send(messageArray) {
+    return new Promise((resolve, reject) => {
+      if (!messageQueue[this.url]) {
+        messageQueue[this.url] = [];
+      }
+      messageQueue[this.url].push({ resolve, reject, messageArray });
+      this._processMessage();
+    });
+  }
+  /**
+   * Processes message queue sequentially to maintain order
+   * @private
+   * @async
+   */
+  async _processMessage() {
+    if (processingQueues[this.url]) {
+      return;
+    }
+    processingQueues[this.url] = true;
+    try {
+      while (messageQueue[this.url] && messageQueue[this.url].length > 0) {
+        const item = messageQueue[this.url].shift();
+        if (!item) break;
+        const { resolve, reject, messageArray } = item;
+        try {
+          const response = await this._sendSingle(messageArray);
+          resolve(response);
+        } catch (error) {
+          reject(error);
+        }
+      }
+    } finally {
+      processingQueues[this.url] = false;
+    }
+  }
+  /**
+   * Sends a single message through websocket connection
+   * @private
+   * @async
+   * @param {Int8Array} messageArray
+   * @returns {Promise<Int8Array>}
+   */
+  _sendSingle(messageArray) {
     return new Promise((resolve, reject) => {
       const client = this.instance;
       if (client && this.isConnected) {
@@ -72,7 +118,7 @@ class WebSocketClientBrowser {
     });
   }
   /**
-   * Disconnects the WebSocket by terminating the connection.
+   * Disconnects the WebSocket by terminating the connection and cleans up queues.
    */
   disconnect() {
     const client = this.instance;
@@ -80,6 +126,13 @@ class WebSocketClientBrowser {
       client.close();
       delete clients[this.url];
     }
+    if (messageQueue[this.url]) {
+      messageQueue[this.url].forEach(({ reject }) => {
+        reject(new Error("WebSocket disconnected"));
+      });
+      delete messageQueue[this.url];
+    }
+    delete processingQueues[this.url];
   }
   /**
    * Connects to the WebSocket server.
@@ -144,5 +197,7 @@ class WebSocketClientBrowser {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   WebSocketClientBrowser,
-  clients
+  clients,
+  messageQueue,
+  processingQueues
 });

package/dist/types/core/webSocketClient/WebSocketClient.d.ts CHANGED Viewed

@@ -1,5 +1,13 @@
 /** @type {Record<string, wsClient>} */
 export const clients: Record<string, wsClient>;
+/** @type {Record<string, Array<{resolve: Function, reject: Function, messageArray: Int8Array}>>} */
+export const messageQueue: Record<string, Array<{
+    resolve: Function;
+    reject: Function;
+    messageArray: Int8Array;
+}>>;
+/** @type {Record<string, boolean>} */
+export const processingQueues: Record<string, boolean>;
 export type wsClient = import("ws").WebSocket;
 export type WebSocketClass = typeof import("ws").WebSocket;
 /**
@@ -21,14 +29,28 @@ export class WebSocketClient {
     get instance(): wsClient | null;
     get isConnected(): boolean;
     /**
-     * Sends messageArray through websocket connection
+     * Sends messageArray through websocket connection with guaranteed order preservation
      * @async
      * @param {Int8Array} messageArray
      * @returns {Promise<Int8Array>}
      */
     send(messageArray: Int8Array): Promise<Int8Array>;
     /**
-     * Disconnects the WebSocket by terminating the connection.
+     * Processes message queue sequentially to maintain order
+     * @private
+     * @async
+     */
+    private _processMessage;
+    /**
+     * Sends a single message through websocket connection
+     * @private
+     * @async
+     * @param {Int8Array} messageArray
+     * @returns {Promise<Int8Array>}
+     */
+    private _send;
+    /**
+     * Disconnects the WebSocket by terminating the connection and cleans up queues.
      */
     disconnect(): void;
     /**

package/dist/types/core/webSocketClient/WebSocketClientBrowser.d.ts CHANGED Viewed

@@ -4,6 +4,14 @@
  */
 /** @type {Record<string, WebSocket>} */
 export const clients: Record<string, WebSocket>;
+/** @type {Record<string, Array<{resolve: Function, reject: Function, messageArray: Int8Array}>>} */
+export const messageQueue: Record<string, Array<{
+    resolve: Function;
+    reject: Function;
+    messageArray: Int8Array;
+}>>;
+/** @type {Record<string, boolean>} */
+export const processingQueues: Record<string, boolean>;
 export type Options = {
     isDisconnectedAfterMessage?: boolean | undefined;
 };
@@ -24,14 +32,28 @@ export class WebSocketClientBrowser {
     get instance(): WebSocket | null;
     get isConnected(): boolean;
     /**
-     * Sends messageArray through websocket connection
+     * Sends messageArray through websocket connection with guaranteed order preservation
      * @async
      * @param {Int8Array} messageArray
      * @returns {Promise<Int8Array>}
      */
     send(messageArray: Int8Array): Promise<Int8Array>;
     /**
-     * Disconnects the WebSocket by terminating the connection.
+     * Processes message queue sequentially to maintain order
+     * @private
+     * @async
+     */
+    private _processMessage;
+    /**
+     * Sends a single message through websocket connection
+     * @private
+     * @async
+     * @param {Int8Array} messageArray
+     * @returns {Promise<Int8Array>}
+     */
+    private _sendSingle;
+    /**
+     * Disconnects the WebSocket by terminating the connection and cleans up queues.
      */
     disconnect(): void;
     /**

package/lib/core/webSocketClient/WebSocketClient.js CHANGED Viewed

@@ -36,6 +36,12 @@ let WebSocket = null
 /** @type {Record<string, wsClient>} */
 export const clients = {}
+/** @type {Record<string, Array<{resolve: Function, reject: Function, messageArray: Int8Array}>>} */
+export const messageQueue = {}
+/** @type {Record<string, boolean>} */
+export const processingQueues = {}
 /**
  * WebSocketClient class that handles WebSocket connection, message sending, and automatic disconnection.
  */
@@ -61,16 +67,65 @@ class WebSocketClient {
     }
     /**
-     * Sends messageArray through websocket connection
+     * Sends messageArray through websocket connection with guaranteed order preservation
      * @async
      * @param {Int8Array} messageArray
      * @returns {Promise<Int8Array>}
      */
     send(messageArray) {
+        return new Promise((resolve, reject) => {
+            if (!messageQueue[this.url]) {
+                messageQueue[this.url] = []
+            }
+            messageQueue[this.url].push({ resolve, reject, messageArray })
+            this._processMessage()
+        })
+    }
+    /**
+     * Processes message queue sequentially to maintain order
+     * @private
+     * @async
+     */
+    async _processMessage() {
+        if (processingQueues[this.url]) {
+            return
+        }
+        processingQueues[this.url] = true
+        try {
+            while (messageQueue[this.url] && messageQueue[this.url].length > 0) {
+                const item = messageQueue[this.url].shift()
+                if (!item) break
+                const { resolve, reject, messageArray } = item
+                try {
+                    const response = await this._send(messageArray)
+                    resolve(response)
+                } catch (error) {
+                    reject(error)
+                }
+            }
+        } finally {
+            processingQueues[this.url] = false
+        }
+    }
+    /**
+     * Sends a single message through websocket connection
+     * @private
+     * @async
+     * @param {Int8Array} messageArray
+     * @returns {Promise<Int8Array>}
+     */
+    _send(messageArray) {
         return new Promise((resolve, reject) => {
             const client = this.instance
-            if (client) {
+            if (client && this.isConnected) {
                 client.send(/** @type {any} */ (messageArray))
                 const messageHandler = (/** @type {any} */ message) => {
                     resolve(message)
                     if (this.isDisconnectedAfterMessage) {
@@ -81,16 +136,16 @@ class WebSocketClient {
                 client.on(WebSocketStateEvent.MESSAGE, messageHandler)
             } else {
                 this._connect()
-                    .then((ws) => {
-                        ws.send(/** @type {any} */ (messageArray))
+                    .then((client) => {
+                        client.send(/** @type {any} */ (messageArray))
                         const messageHandler = (/** @type {any} */ message) => {
                             resolve(message)
                             if (this.isDisconnectedAfterMessage) {
                                 this.disconnect()
                             }
-                            ws.removeListener(WebSocketStateEvent.MESSAGE, messageHandler)
+                            client.removeListener(WebSocketStateEvent.MESSAGE, messageHandler)
                         }
-                        ws.on(WebSocketStateEvent.MESSAGE, messageHandler)
+                        client.on(WebSocketStateEvent.MESSAGE, messageHandler)
                     })
                     .catch(reject)
             }
@@ -98,13 +153,24 @@ class WebSocketClient {
     }
     /**
-     * Disconnects the WebSocket by terminating the connection.
+     * Disconnects the WebSocket by terminating the connection and cleans up queues.
      */
     disconnect() {
         if (this.instance) {
             this.instance.close()
             delete clients[this.url]
         }
+        // Clean up message queue and processing state
+        if (messageQueue[this.url]) {
+            // Reject any pending messages
+            messageQueue[this.url].forEach(({ reject }) => {
+                reject(new Error('WebSocket disconnected'))
+            })
+            delete messageQueue[this.url]
+        }
+        delete processingQueues[this.url]
     }
     /**

package/lib/core/webSocketClient/WebSocketClientBrowser.js CHANGED Viewed

@@ -25,6 +25,12 @@ if (isBrowserRuntime()) {
 /** @type {Record<string, WebSocket>} */
 export const clients = {}
+/** @type {Record<string, Array<{resolve: Function, reject: Function, messageArray: Int8Array}>>} */
+export const messageQueue = {}
+/** @type {Record<string, boolean>} */
+export const processingQueues = {}
 /**
  * WebSocketClient class that handles WebSocket connection, message sending, and automatic disconnection.
  */
@@ -51,12 +57,59 @@ class WebSocketClientBrowser {
     }
     /**
-     * Sends messageArray through websocket connection
+     * Sends messageArray through websocket connection with guaranteed order preservation
      * @async
      * @param {Int8Array} messageArray
      * @returns {Promise<Int8Array>}
      */
     send(messageArray) {
+        return new Promise((resolve, reject) => {
+            if (!messageQueue[this.url]) {
+                messageQueue[this.url] = []
+            }
+            messageQueue[this.url].push({ resolve, reject, messageArray })
+            this._processMessage()
+        })
+    }
+    /**
+     * Processes message queue sequentially to maintain order
+     * @private
+     * @async
+     */
+    async _processMessage() {
+        if (processingQueues[this.url]) {
+            return
+        }
+        processingQueues[this.url] = true
+        try {
+            while (messageQueue[this.url] && messageQueue[this.url].length > 0) {
+                const item = messageQueue[this.url].shift()
+                if (!item) break
+                const { resolve, reject, messageArray } = item
+                try {
+                    const response = await this._sendSingle(messageArray)
+                    resolve(response)
+                } catch (error) {
+                    reject(error)
+                }
+            }
+        } finally {
+            processingQueues[this.url] = false
+        }
+    }
+    /**
+     * Sends a single message through websocket connection
+     * @private
+     * @async
+     * @param {Int8Array} messageArray
+     * @returns {Promise<Int8Array>}
+     */
+    _sendSingle(messageArray) {
         return new Promise((resolve, reject) => {
             const client = this.instance
             if (client && this.isConnected) {
@@ -72,7 +125,7 @@ class WebSocketClientBrowser {
     }
     /**
-     * Disconnects the WebSocket by terminating the connection.
+     * Disconnects the WebSocket by terminating the connection and cleans up queues.
      */
     disconnect() {
         const client = this.instance
@@ -80,6 +133,14 @@ class WebSocketClientBrowser {
             client.close()
             delete clients[this.url]
         }
+        if (messageQueue[this.url]) {
+            messageQueue[this.url].forEach(({ reject }) => {
+                reject(new Error('WebSocket disconnected'))
+            })
+            delete messageQueue[this.url]
+        }
+        delete processingQueues[this.url]
     }
     /**

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
     "name": "javonet-nodejs-sdk",
-    "version": "2.6.0",
+    "version": "2.6.1",
     "description": "Javonet allows you to reference and use modules or packages written in (Java/Kotlin/Groovy/Clojure, C#/VB.NET, Ruby, Perl, Python, JavaScript/TypeScript) like they were created in your technology. It works on Linux/Windows and MacOS for applications created in JVM, CLR/Netcore, Perl, Python, Ruby, NodeJS, C++ or GoLang and gives you unparalleled freedom and flexibility with native performance in building your mixed-technologies products. Let it be accessing best AI or cryptography libraries, devices SDKs, legacy client modules, internal custom packages or anything from public repositories available on NPM, Nuget, PyPI, Maven/Gradle, RubyGems or GitHub. Get free from programming languages barriers today! For more information check out our guides at https://www.javonet.com/guides/v2/",
     "keywords": [],
     "author": "SdNCenter Sp. z o. o.",