javonet-nodejs-sdk 2.5.13 → 2.5.15

package/Binaries/Native/Linux/ARM64/version.txt

@@ -1 +1 @@
-2.5.13
+2.5.15

package/Binaries/Native/Linux/X64/version.txt

@@ -1 +1 @@
-2.5.13
+2.5.15

package/Binaries/Native/MacOs/X64/version.txt

@@ -1 +1 @@
-2.5.13
+2.5.15

package/Binaries/Native/Windows/X64/version.txt

@@ -1 +1 @@
-'2.5.13' 
+'2.5.15' 

package/Binaries/Native/Windows/X86/version.txt

@@ -1 +1 @@
-'2.5.13' 
+'2.5.15' 

package/Binaries/Nodejs/lib/core/interpreter/Interpreter.js

@@ -44,6 +44,8 @@ class Interpreter {
                     if (_response) {
                         const command = new CommandDeserializer(_response).deserialize()
                         return command
+                    } else {
+                        throw new Error('Response not received from TransmitterWebsocket')
                     }
                 } catch (error) {
                     // TODO: handle error exception log?
@@ -98,6 +100,8 @@ class Interpreter {
                         if (_response) {
                             const command = new CommandDeserializer(_response).deserialize()
                             return command
+                        } else {
+                            throw new Error('Response not received from TransmitterWebsocket')
                         }
                     })
                     .catch((error) => {

package/Binaries/Nodejs/lib/core/protocol/CommandDeserializer.js

@@ -56,21 +56,37 @@ class CommandDeserializer {
     }
 
     readCommand() {
-        const p = this.position
-        const numberOfElementsInPayload = TypeDeserializer.deserializeInt(this.buffer.slice(p + 1, p + 5))
-        const runtime = this.buffer[p + 5]
-        const type = this.buffer[p + 6]
-        this.position += 7
-        const command = new Command(runtime, type, [])
-        return this.readCommandRecursively(numberOfElementsInPayload, command)
-    }
+        const p = this.position;
+        const numberOfElementsInPayload = TypeDeserializer.deserializeInt(this.buffer.slice(p + 1, p + 5));
+        const runtime = this.buffer[p + 5];
+        const commandType = this.buffer[p + 6];
+        this.position += 7;
+
+        const payload = new Array(numberOfElementsInPayload);
+        for (let i = 0; i < numberOfElementsInPayload; i++) {
+            payload[i] = this.readObject(this.buffer[this.position]);
+        }
 
-    readCommandRecursively(numberOfElementsInPayloadLeft, cmd) {
-        if (numberOfElementsInPayloadLeft === 0) return cmd
-        const p = this.position
-        cmd = cmd.addArgToPayload(this.readObject(this.buffer[p]))
-        return this.readCommandRecursively(numberOfElementsInPayloadLeft - 1, cmd)
-    }
+        return new Command(runtime, commandType, payload);
+    }
+
+    // old implementation
+    // readCommand() {
+    //     const p = this.position
+    //     const numberOfElementsInPayload = TypeDeserializer.deserializeInt(this.buffer.slice(p + 1, p + 5))
+    //     const runtime = this.buffer[p + 5]
+    //     const type = this.buffer[p + 6]
+    //     this.position += 7
+    //     const command = new Command(runtime, type, [])
+    //     return this.readCommandRecursively(numberOfElementsInPayload, command)
+    // }
+    //
+    // readCommandRecursively(numberOfElementsInPayloadLeft, cmd) {
+    //     if (numberOfElementsInPayloadLeft === 0) return cmd
+    //     const p = this.position
+    //     cmd = cmd.addArgToPayload(this.readObject(this.buffer[p]))
+    //     return this.readCommandRecursively(numberOfElementsInPayloadLeft - 1, cmd)
+    // }
 
     readString() {
         let p = this.position

package/Binaries/Nodejs/lib/core/protocol/CommandSerializer.js

@@ -1,37 +1,50 @@
-const Command = require('../../utils/Command')
-const TypeEncoder = require('./TypeSerializer')
-const Runtime = require('../../utils/RuntimeName')
+
+const Command = require('../../utils/Command');
+const TypeSerializer = require('./TypeSerializer');
+const RuntimeName = require('../../utils/RuntimeName');
 
 class CommandSerializer {
-    buffer = new Int8Array(2)
-
-    serialize(root_command, connectionData, runtimeVersion = 0) {
-        this.buffer[0] = root_command.runtimeName
-        this.buffer[1] = runtimeVersion
-        this.#insertIntoBuffer(connectionData.serializeConnectionData())
-        this.#insertIntoBuffer(new Int8Array([Runtime.Nodejs, root_command.commandType]))
-        this.#serializeRecursively(root_command)
-        return this.buffer
+    serialize(rootCommand, connectionData) {
+        const buffers = [];
+        // Write runtime name and a zero byte for runtime version.
+        buffers.push(Uint8Array.of(rootCommand.runtimeName, 0));
+
+        if (connectionData) {
+            buffers.push(connectionData.serializeConnectionData());
+        } else {
+
+            buffers.push(Uint8Array.of(0, 0, 0, 0, 0, 0, 0));
+        }
+
+        buffers.push(Uint8Array.of(RuntimeName.Nodejs, rootCommand.commandType));
+
+        this.serializeRecursively(rootCommand, buffers);
+
+        return concatenateUint8Arrays(buffers);
     }
 
-    #serializeRecursively = function (root_command) {
-        for (let cmd of root_command.payload) {
-            if (cmd instanceof Command) {
-                this.#insertIntoBuffer(TypeEncoder.serializeCommand(cmd))
-                this.#serializeRecursively(cmd)
+    serializeRecursively(command, buffers) {
+        for (const item of command.payload) {
+            if (item instanceof Command) {
+                buffers.push(TypeSerializer.serializeCommand(item));
+                this.serializeRecursively(item, buffers);
             } else {
-                let result = TypeEncoder.encodePrimitive(cmd)
-                this.#insertIntoBuffer(result)
+                buffers.push(TypeSerializer.serializePrimitive(item));
             }
         }
     }
+}
+
+function concatenateUint8Arrays(arrays) {
+    let totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+    const result = new Uint8Array(totalLength);
 
-    #insertIntoBuffer = function (arg) {
-        let newArray = new Int8Array(this.buffer.length + arg.length)
-        newArray.set(this.buffer, 0)
-        newArray.set(arg, this.buffer.length)
-        this.buffer = newArray
+    let offset = 0;
+    for (const arr of arrays) {
+        result.set(arr, offset);
+        offset += arr.length;
     }
+    return result;
 }
 
-module.exports = CommandSerializer
+module.exports = CommandSerializer;

package/Binaries/Nodejs/lib/core/protocol/TypeSerializer.js

@@ -7,7 +7,7 @@ const CustomError = require('../../utils/CustomError')
 const encoder = new TextEncoder()
 
 class TypeSerializer {
-    static encodePrimitive(payload_item) {
+    static serializePrimitive(payload_item) {
         if (payload_item === null) {
             return TypeSerializer.serializeNull()
         }

package/Binaries/Nodejs/lib/core/webSocketClient/WebSocketClient.js

@@ -41,6 +41,31 @@ class WebSocketClient {
         this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? true
     }
 
+    /**
+     * Connects to the WebSocket server.
+     * @async
+     * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
+     */
+    connect() {
+        return new Promise((resolve, reject) => {
+            const client = new WebSocket(this.url)
+
+            client.on(WebSocketStateEnum.OPEN, () => {
+                this.instance = client;
+                resolve(client);
+            })
+
+            // eslint-disable-next-line no-unused-vars
+            client.on(WebSocketStateEnum.ERROR, (error) => {
+                reject(error)
+            })
+
+            client.on(WebSocketStateEnum.CLOSE, () => {
+                reject(new Error("Connection closed before receiving message"))
+            })
+        });
+    }
+
     /**
      * Sends messageArray through websocket connection
      * @async
@@ -49,17 +74,23 @@ class WebSocketClient {
      */
     send(messageArray) {
         return new Promise((resolve, reject) => {
-            try {
-                if (this.isConnected) {
-                    this._sendMessage(messageArray, resolve, reject)
-                } else {
-                    this._connect().then(() => {
-                        this._sendMessage(messageArray, resolve, reject)
-                    })
-                }
-            } catch (error) {
+            (this.instance ? Promise.resolve(this.instance) : this._connect()).then((client) => {
+                client.send(messageArray, (err) => {
+                    if (err) {
+                        reject(err)
+                    }
+                })
+
+                client.on('message', (message) => {
+                    resolve(message)
+
+                    if (this.isDisconnectedAfterMessage) {
+                        this.disconnect()
+                    }
+                })
+            }).catch((error) => {
                 reject(error)
-            }
+            })
         })
     }
 
@@ -69,6 +100,7 @@ class WebSocketClient {
     disconnect() {
         if (this.instance) {
             this.instance.close()
+            this.instance = null
         }
         this.isConnected = false
     }
@@ -77,55 +109,28 @@ class WebSocketClient {
      * Connects to the WebSocket server.
      * @private
      * @async
-     * @returns {Promise<void>} - A promise that resolves when the connection is established.
+     * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
      */
     _connect() {
         return new Promise((resolve, reject) => {
-            this.instance = new WebSocket(this.url)
+            const client = new WebSocket(this.url)
 
-            this.instance.on(WebSocketStateEnum.OPEN, () => {
+            client.on(WebSocketStateEnum.OPEN, () => {
                 this.isConnected = true
-                resolve()
+                this.instance = client;
+                resolve(client)
             })
 
             // eslint-disable-next-line no-unused-vars
-            this.instance.on(WebSocketStateEnum.ERROR, (error) => {
-                reject(null)
+            client.on(WebSocketStateEnum.ERROR, (error) => {
+                reject(error)
             })
 
-            this.instance.on(WebSocketStateEnum.CLOSE, () => {
-                this.isConnected = false
+            client.on(WebSocketStateEnum.CLOSE, () => {
+                reject(new Error("Connection closed before receiving message"))
             })
         })
     }
-
-    /**
-     * Sends the data to the WebSocket server and listens for a response.
-     * @private
-     * @async
-     * @param {string|Buffer|ArrayBuffer|Buffer[]} data - The data to send.
-     * @param {Function} resolve - The resolve function for the Promise.
-     * @param {Function} reject - The reject function for the Promise.
-     */
-    _sendMessage(data, resolve, reject) {
-        this.instance.send(data, (err) => {
-            if (err) {
-                reject(err)
-            }
-        })
-
-        this.instance.on('message', (message) => {
-            resolve(message)
-
-            if (this.isDisconnectedAfterMessage) {
-                this.disconnect()
-            }
-        })
-
-        this.instance.on('error', (error) => {
-            reject(error)
-        })
-    }
 }
 
 module.exports = WebSocketClient

package/Binaries/Nodejs/lib/sdk/ConfigRuntimeFactory.js

@@ -91,6 +91,16 @@ class ConfigRuntimeFactory {
         return this.#getRuntimeContext(RuntimeName.Nodejs, configName)
     }
 
+    /**
+     * Creates RuntimeContext instance to interact with the Python 2.7 runtime.
+     * @param {string} [configName="default"] - The name of the configuration to use (optional).
+     * @return {RuntimeContext} a RuntimeContext instance for the Python 2.7 runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    python27(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Python27, configName)
+    }
+
     #getRuntimeContext(runtime, configName = 'default') {
         let jfr = new JsonFileResolver(this.path)
 

package/Binaries/Nodejs/lib/sdk/InvocationContext.js

@@ -408,16 +408,14 @@ class InvocationContext {
         } else if (typeof payloadItem === 'InvocationContext' || payloadItem instanceof InvocationContext) {
             return payloadItem.get_current_command()
         } else if (payloadItem instanceof Array) {
-            for (let i = 0; i < payloadItem.length; i++) {
-                payloadItem[i] = this.#encapsulatePayloadItem(payloadItem[i])
-            }
-            return new Command(this.runtimeName, CommandType.Array, payloadItem)
+            const copiedArray = payloadItem.map((item) => this.#encapsulatePayloadItem(item))
+            return new Command(this.runtimeName, CommandType.Array, copiedArray)
         } else if (typeof payloadItem === 'function') {
             let newArray = new Array(payloadItem.length + 1)
             for (let i = 0; i < newArray.length; i++) {
                 newArray[i] = typeof Object
             }
-            const args = [DelegatesCache.addDelegate(payloadItem), RuntimeName.Nodejs].push(...newArray);
+            const args = [DelegatesCache.addDelegate(payloadItem), RuntimeName.Nodejs].push(...newArray)
             return new Command(this.#runtimeName, CommandType.PassDelegate, args)
         } else {
             return new Command(this.runtimeName, CommandType.Value, [payloadItem])

package/Binaries/Nodejs/lib/sdk/Javonet.js

@@ -43,7 +43,7 @@ class Javonet {
      * @returns {RuntimeFactory} A RuntimeFactory instance configured for a WebSocket connection.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/websocket-channel)
      */
-    static ws(wsConnectionData) {
+    static webSocket(wsConnectionData) {
         return new RuntimeFactory(wsConnectionData)
     }