javonet-nodejs-sdk 2.6.4 → 2.6.6

package/lib/core/interpreter/Interpreter.js

@@ -14,10 +14,10 @@ import { Handler } from '../handler/Handler.js'
  * @typedef {import('../../utils/Command.js').Command} Command
  */
 
-/** @type {typeof import('../receiver/Receiver.js').Receiver | null} */
-let _Receiver = null
-/** @type {typeof import('../transmitter/Transmitter.js').Transmitter | null} */
-let _Transmitter = null
+/** @type {typeof import('../receiver/Receiver.js').Receiver} */
+let _Receiver
+/** @type {typeof import('../transmitter/Transmitter.js').Transmitter} */
+let _Transmitter
 /** @type {typeof import('../transmitter/TransmitterWebsocket.js').TransmitterWebsocket | typeof import('../transmitter/TransmitterWebsocketBrowser.js').TransmitterWebsocketBrowser | null} */
 let _TransmitterWebsocket = null
 
@@ -48,11 +48,14 @@ export class Interpreter {
     async executeAsync(command, connectionData) {
         try {
             let messageByteArray = new CommandSerializer().serialize(command, connectionData)
-            /** @type {Int8Array | undefined} */
+            /** @type {Uint8Array | undefined} */
             let responseByteArray = undefined
 
             if (connectionData.connectionType === ConnectionType.WEB_SOCKET) {
-                const _response = await _TransmitterWebsocket?.sendCommand(messageByteArray, connectionData)
+                const _response = await _TransmitterWebsocket?.sendCommand(
+                    await messageByteArray,
+                    connectionData
+                )
                 if (_response) {
                     const command = new CommandDeserializer(_response).deserialize()
                     return command
@@ -69,13 +72,13 @@ export class Interpreter {
                         const { Receiver } = requireDynamic('../receiver/Receiver.js')
                         _Receiver = Receiver
                     }
-                    responseByteArray = await _Receiver?.sendCommand(messageByteArray)
+                    responseByteArray = await _Receiver?.sendCommand(await messageByteArray)
                 } else {
                     if (!_Transmitter) {
                         const { Transmitter } = requireDynamic('../transmitter/Transmitter.js')
                         _Transmitter = Transmitter
                     }
-                    responseByteArray = await _Transmitter?.sendCommand(messageByteArray)
+                    responseByteArray = await _Transmitter?.sendCommand(await messageByteArray)
                 }
             }
 
@@ -98,37 +101,61 @@ export class Interpreter {
     execute(command, connectionData) {
         try {
             let messageByteArray = new CommandSerializer().serialize(command, connectionData)
-            /** @type {Int8Array | undefined} */
+            /** @type {Promise<Uint8Array> | Uint8Array | undefined} */
             let responseByteArray = undefined
 
             if (connectionData.connectionType === ConnectionType.WEB_SOCKET) {
                 throw new Error('Not supported')
             }
-            if (connectionData.connectionType === ConnectionType.IN_MEMORY) {
+            else {
                 if (!isNodejsRuntime()) {
                     throw new Error('InMemory is only allowed in Nodejs runtime')
                 }
 
-                if (command.runtimeName === RuntimeName.Nodejs) {
+                if (command.runtimeName === RuntimeName.Nodejs && connectionData.connectionType === ConnectionType.IN_MEMORY) {
                     if (!_Receiver) {
                         const { Receiver } = requireDynamic('../receiver/Receiver.js')
                         _Receiver = Receiver
                     }
-                    responseByteArray = _Receiver?.sendCommand(messageByteArray)
+                    if (!_Receiver) {
+                        throw new Error('Receiver is undefined')
+                    }
+                    if (messageByteArray instanceof Uint8Array) {
+                        responseByteArray = _Receiver.sendCommand(messageByteArray)
+                    } else {
+                        responseByteArray = messageByteArray.then((resolvedMessage) => {
+                            return _Receiver.sendCommand(resolvedMessage)
+                        })
+                    }
                 } else {
                     if (!_Transmitter) {
                         const { Transmitter } = requireDynamic('../transmitter/Transmitter.js')
                         _Transmitter = Transmitter
                     }
-                    responseByteArray = _Transmitter?.sendCommand(messageByteArray)
+                    if (!_Transmitter) {
+                        throw new Error('Transmitter is undefined')
+                    }
+                    if (messageByteArray instanceof Uint8Array) {
+                        responseByteArray = _Transmitter.sendCommand(messageByteArray)
+                    } else {
+                        responseByteArray = messageByteArray.then((resolvedMessage) => {
+                            return _Transmitter.sendCommand(resolvedMessage)
+                        })
+                    }
                 }
-            }
 
-            if (!responseByteArray) {
-                throw new Error('No response received from Transmitter')
-            }
+                if (!responseByteArray) {
+                    throw new Error('No response received from Transmitter')
+                }
 
-            return new CommandDeserializer(responseByteArray).deserialize()
+                if (responseByteArray instanceof Promise) {
+                    return responseByteArray.then((resolvedResponse) => {
+                        return new CommandDeserializer(resolvedResponse).deserialize()
+                    })
+                } else {
+                    return new CommandDeserializer(responseByteArray).deserialize()
+                }
+            }
         } catch (error) {
             throw error
         }
@@ -136,8 +163,8 @@ export class Interpreter {
 
     /**
      *
-     * @param {Int8Array} messageByteArray
-     * @returns {Command}
+     * @param {Uint8Array} messageByteArray
+     * @returns {Promise<Command> | Command}
      */
     process(messageByteArray) {
         try {

package/lib/core/protocol/CommandDeserializer.js

@@ -5,11 +5,11 @@ import { TypeDeserializer } from './TypeDeserializer.js'
 
 export class CommandDeserializer {
     /**
-     * @param {Int8Array} buffer
+     * @param {Uint8Array} byteArray
      */
-    constructor(buffer) {
-        this.buffer = buffer
-        this.command = new Command(buffer[0], buffer[10], [])
+    constructor(byteArray) {
+        this.buffer = byteArray
+        this.command = new Command(this.buffer[0], this.buffer[10], [])
         this.position = 11
     }
 

package/lib/core/protocol/CommandSerializer.js

@@ -11,15 +11,21 @@ import { TypesHandler } from '../../utils/TypesHandler.js'
 class CommandSerializer {
     /**
      * Serializes the root command with connection data and optional runtime version.
-     * @param {Command} rootCommand
+     * @param {Promise<Command> | Command} rootCommand
      * @param {IConnectionData} connectionData
      * @param {number} runtimeVersion
-     * @returns {Int8Array}
+     * @returns {Promise<Uint8Array> | Uint8Array}
      */
     serialize(rootCommand, connectionData, runtimeVersion = 0) {
         const buffers = []
 
         // Write runtime name and version
+        if (rootCommand instanceof Promise) {
+            return rootCommand.then(resolvedCommand => {
+                return this.serialize(resolvedCommand, connectionData, runtimeVersion)
+            })
+        }
+
         buffers.push(Uint8Array.of(rootCommand.runtimeName, runtimeVersion))
 
         // Write connection data or default zeros

package/lib/core/protocol/TypeDeserializer.js

@@ -5,7 +5,7 @@ import { StringEncodingMode } from '../../utils/StringEncodingMode.js'
 
 export class TypeDeserializer {
     /**
-     * @param {Int8Array} encodedCommand
+     * @param {Uint8Array} encodedCommand
      * @returns {Command}
      */
     static deserializeCommand(encodedCommand) {
@@ -14,7 +14,7 @@ export class TypeDeserializer {
 
     /**
      * @param {number} stringEncodingMode
-     * @param {Int8Array} encodedString
+     * @param {Uint8Array} encodedString
      */
     static deserializeString(stringEncodingMode, encodedString) {
         switch (stringEncodingMode) {
@@ -43,7 +43,7 @@ export class TypeDeserializer {
     }
 
     /**
-     * @param {Int8Array} encodedInt
+     * @param {Uint8Array} encodedInt
      */
     static deserializeInt(encodedInt) {
         return (
@@ -55,56 +55,56 @@ export class TypeDeserializer {
     }
 
     /**
-     * @param {Int8Array} encodedBool
+     * @param {Uint8Array} encodedBool
      */
     static deserializeBool(encodedBool) {
         return encodedBool[0] === 1
     }
 
     /**
-     * @param {Int8Array} encodedFloat
+     * @param {Uint8Array} encodedFloat
      */
     static deserializeFloat(encodedFloat) {
         return Buffer.from(encodedFloat).readFloatLE()
     }
 
     /**
-     * @param {Int8Array} encodedByte
+     * @param {Uint8Array} encodedByte
      */
     static deserializeByte(encodedByte) {
         return Buffer.from(encodedByte).readUint8()
     }
 
     /**
-     * @param {Int8Array} encodedChar
+     * @param {Uint8Array} encodedChar
      */
     static deserializeChar(encodedChar) {
         return Buffer.from(encodedChar).readUint8()
     }
 
     /**
-     * @param {Int8Array} encodedLongLong
+     * @param {Uint8Array} encodedLongLong
      */
     static deserializeLongLong(encodedLongLong) {
         return Buffer.from(encodedLongLong).readBigInt64LE()
     }
 
     /**
-     * @param {Int8Array} encodedDouble
+     * @param {Uint8Array} encodedDouble
      */
     static deserializeDouble(encodedDouble) {
         return Buffer.from(encodedDouble).readDoubleLE()
     }
 
     /**
-     * @param {Int8Array} encodedULLong
+     * @param {Uint8Array} encodedULLong
      */
     static deserializeULLong(encodedULLong) {
         return Buffer.from(encodedULLong).readBigUInt64LE()
     }
 
     /**
-     * @param {Int8Array} encodedUInt
+     * @param {Uint8Array} encodedUInt
      */
     static deserializeUInt(encodedUInt) {
         return Buffer.from(encodedUInt).readUIntLE(0, 4)

package/lib/core/receiver/Receiver.js

@@ -18,14 +18,13 @@ export class Receiver {
     }
 
     /**
-     * @param {Int8Array} messageByteArray
+     * @param {Uint8Array} messageByteArray
+     * @returns {Promise<Uint8Array> | Uint8Array}
      */
     static sendCommand(messageByteArray) {
         try {
-            return new CommandSerializer().serialize(
-                new Interpreter().process(messageByteArray),
-                this.connectionData
-            )
+            let command = new Interpreter().process(messageByteArray)
+            return new CommandSerializer().serialize(command, this.connectionData)
         } catch (error) {
             const exceptionCommand = ExceptionSerializer.serializeException(
                 error,
@@ -36,11 +35,11 @@ export class Receiver {
     }
 
     /**
-     * @param {Int8Array} messageByteArray
-     * @returns {Int8Array}
+     * @param {Uint8Array} messageByteArray
+     * @returns {Promise<Uint8Array> | Uint8Array}
      */
     static heartBeat(messageByteArray) {
-        let response = new Int8Array(2)
+        let response = new Uint8Array(2)
         response[0] = messageByteArray[11]
         response[1] = messageByteArray[12] - 2
         return response

package/lib/core/receiver/ReceiverNative.js

@@ -3,14 +3,16 @@ import { Receiver } from './Receiver.js'
 
 export class ReceiverNative {
     /**
-     * @param {Int8Array} messageByteArray
+     * @param {Uint8Array} messageByteArray
+     * @returns {Promise<Uint8Array> | Uint8Array}
      */
     static sendCommand(messageByteArray) {
         return Receiver.sendCommand(messageByteArray)
     }
 
     /**
-     * @param {Int8Array} messageByteArray
+     * @param {Uint8Array} messageByteArray
+     * @returns {Uint8Array | Promise<Uint8Array>}
      */
     static heartBeat(messageByteArray) {
         return Receiver.heartBeat(messageByteArray)

package/lib/core/transmitter/Transmitter.js

@@ -3,8 +3,8 @@ import { TransmitterWrapper } from './TransmitterWrapper.js'
 
 export class Transmitter {
     /**
-     * @param {Int8Array} messageArray
-     * @returns {Int8Array}
+     * @param {Uint8Array} messageArray
+     * @returns {Uint8Array}
      */
     static sendCommand(messageArray) {
         return TransmitterWrapper.sendCommand(messageArray)

package/lib/core/transmitter/TransmitterWebsocket.js

@@ -22,9 +22,9 @@ export class TransmitterWebsocket {
 
     /**
      * @async
-     * @param {Int8Array} messageByteArray
+     * @param {Uint8Array} messageByteArray
      * @param {IConnectionData} connectionData
-     * @returns {Promise<Int8Array>} responseByteArray
+     * @returns {Promise<Uint8Array>} responseByteArray
      */
     static sendCommand(messageByteArray, connectionData) {
         const { hostname } = connectionData

package/lib/core/transmitter/TransmitterWebsocketBrowser.js

@@ -17,9 +17,9 @@ export class TransmitterWebsocketBrowser {
 
     /**
      * @async
-     * @param {Int8Array} messageByteArray
+     * @param {Uint8Array} messageByteArray
      * @param {IConnectionData} connectionData
-     * @returns {Promise<Int8Array>} responseByteArray
+     * @returns {Promise<Uint8Array>} responseByteArray
      */
     static async sendCommand(messageByteArray, connectionData) {
         const { hostname } = connectionData

package/lib/core/transmitter/TransmitterWrapper.js

@@ -54,7 +54,8 @@ class TransmitterWrapper {
     }
 
     /**
-     * @param {Int8Array} messageArray
+     * @param {Uint8Array} messageArray
+     * @returns {Uint8Array}
      */
     static sendCommand(messageArray) {
         this.loadNativeLibrary()

package/lib/core/webSocketClient/WebSocketClient.js

@@ -36,7 +36,7 @@ let WebSocket = null
 /** @type {Record<string, wsClient>} */
 export const clients = {}
 
-/** @type {Record<string, Array<{resolve: Function, reject: Function, messageArray: Int8Array}>>} */
+/** @type {Record<string, Array<{resolve: Function, reject: Function, messageArray: Uint8Array}>>} */
 export const messageQueue = {}
 
 /** @type {Record<string, boolean>} */
@@ -69,8 +69,8 @@ class WebSocketClient {
     /**
      * Sends messageArray through websocket connection with guaranteed order preservation
      * @async
-     * @param {Int8Array} messageArray
-     * @returns {Promise<Int8Array>}
+     * @param {Uint8Array} messageArray
+     * @returns {Promise<Uint8Array>}
      */
     send(messageArray) {
         return new Promise((resolve, reject) => {
@@ -117,8 +117,8 @@ class WebSocketClient {
      * Sends a single message through websocket connection
      * @private
      * @async
-     * @param {Int8Array} messageArray
-     * @returns {Promise<Int8Array>}
+     * @param {Uint8Array} messageArray
+     * @returns {Promise<Uint8Array>}
      */
     _send(messageArray) {
         return new Promise((resolve, reject) => {

package/lib/core/webSocketClient/WebSocketClientBrowser.js

@@ -25,7 +25,7 @@ if (isBrowserRuntime()) {
 /** @type {Record<string, WebSocket>} */
 export const clients = {}
 
-/** @type {Record<string, Array<{resolve: Function, reject: Function, messageArray: Int8Array}>>} */
+/** @type {Record<string, Array<{resolve: Function, reject: Function, messageArray: Uint8Array}>>} */
 export const messageQueue = {}
 
 /** @type {Record<string, boolean>} */
@@ -59,8 +59,8 @@ class WebSocketClientBrowser {
     /**
      * Sends messageArray through websocket connection with guaranteed order preservation
      * @async
-     * @param {Int8Array} messageArray
-     * @returns {Promise<Int8Array>}
+     * @param {Uint8Array} messageArray
+     * @returns {Promise<Uint8Array>}
      */
     send(messageArray) {
         return new Promise((resolve, reject) => {
@@ -106,8 +106,8 @@ class WebSocketClientBrowser {
      * Sends a single message through websocket connection
      * @private
      * @async
-     * @param {Int8Array} messageArray
-     * @returns {Promise<Int8Array>}
+     * @param {Uint8Array} messageArray
+     * @returns {Promise<Uint8Array>}
      */
     _sendSingle(messageArray) {
         return new Promise((resolve, reject) => {
@@ -174,8 +174,8 @@ class WebSocketClientBrowser {
      * Sends the data to the WebSocket server and listens for a response.
      * @private
      * @param {WebSocket} client
-     * @param {Int8Array} data
-     * @param {(value: Int8Array) => void} resolve
+     * @param {Uint8Array} data
+     * @param {(value: Uint8Array) => void} resolve
      * @param {(reason?: any) => void} reject
      */
     _sendMessage(client, data, resolve, reject) {
@@ -188,7 +188,7 @@ class WebSocketClientBrowser {
                     return reject(new Error('Invalid message received'))
                 }
 
-                const byteArray = new Int8Array(message?.data)
+                const byteArray = new Uint8Array(message?.data)
                 resolve(byteArray)
 
                 if (this.isDisconnectedAfterMessage) {

package/lib/sdk/InvocationContext.js

@@ -27,12 +27,10 @@ class InvocationContext {
     #connectionData
     /** @type {Command | null} */
     #currentCommand = null
-    /** @type {Command | null} */
+    /** @type {Command | Promise<Command> | null} */
     #responseCommand = null
     /** @type {boolean} */
     #isExecuted = false
-    /** @type {any | null} */
-    #resultValue = null
     /** @type {Interpreter | null} */
     #interpreter = null
 
@@ -50,7 +48,6 @@ class InvocationContext {
         this.#responseCommand = null
         this.#isExecuted = isExecuted
         this.#interpreter = null
-        this.#resultValue = null
     }
 
     /**
@@ -59,7 +56,6 @@ class InvocationContext {
      */
     #createInstanceContext(localCommand) {
         if (this.#connectionData.connectionType === ConnectionType.WEB_SOCKET) {
-            // @ts-expect-error
             return new InvocationWsContext(
                 this.#runtimeName,
                 this.#connectionData,
@@ -96,7 +92,17 @@ class InvocationContext {
             throw new Error('Object is not iterable')
         }
         let position = -1
-        const arraySize = Number(this.getSize().execute().getValue())
+        /** @type {number} */
+        let arraySize = 0
+        /** @type {InvocationContext | Promise<InvocationContext>} */
+        const sizeCtx = /** @type {any} */ (this.getSize().execute())
+        if (sizeCtx instanceof Promise) {
+          sizeCtx.then((ctx) => {
+              arraySize = Number(ctx.getValue())
+          })
+        } else {
+        arraySize = Number(sizeCtx.getValue())
+          }
 
         return {
             next: () => ({
@@ -113,7 +119,7 @@ class InvocationContext {
      * Commands are becoming nested through each invocation of methods on Invocation Context.
      * Each invocation triggers the creation of new Invocation Context instance wrapping the current command with new parent command valid for invoked method.
      * Developer can decide on any moment of the materialization for the context taking full control of the chunks of the expression being transferred and processed on target runtime.
-     * @returns {InvocationContext} the InvocationContext after executing the command.
+     * @returns {Promise<InvocationContext> | InvocationContext} the InvocationContext after executing the command.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
      * @method
      */
@@ -125,22 +131,29 @@ class InvocationContext {
         if (!this.#interpreter) {
             this.#interpreter = new Interpreter()
         }
-        //@ts-expect-error
+
         this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.#connectionData)
 
-        if (!this.#responseCommand) {
-            throw new Error('responseCommand is undefined in Invocation Context execute method')
-        }
-        if (this.#responseCommand?.commandType === CommandType.Exception) {
-            throw ExceptionThrower.throwException(this.#responseCommand)
-        }
-        if (this.#responseCommand?.commandType === CommandType.CreateClassInstance) {
-            this.#currentCommand = this.#responseCommand
-            this.#isExecuted = true
-            return this
+        const handleResponse = (/** @type {Command } */ resolvedResponse) => {
+            if (!resolvedResponse) {
+                throw new Error('responseCommand is undefined in Invocation Context execute method')
+            }
+            if (resolvedResponse.commandType === CommandType.Exception) {
+                throw ExceptionThrower.throwException(resolvedResponse)
+            }
+            if (resolvedResponse.commandType === CommandType.CreateClassInstance) {
+                this.#currentCommand = resolvedResponse
+                this.#isExecuted = true
+                return this
+            }
+            return new InvocationContext(this.#runtimeName, this.#connectionData, resolvedResponse, true)
         }
 
-        return new InvocationContext(this.#runtimeName, this.#connectionData, this.#responseCommand, true)
+        if (this.#responseCommand instanceof Promise) {
+            return this.#responseCommand.then(handleResponse)
+        } else {
+            return handleResponse(this.#responseCommand)
+        }
     }
 
     /**
@@ -397,7 +410,7 @@ class InvocationContext {
 
     /**
      * Retrieves the type of the object from the target runtime.
-     * @returns {string} The type of the object.
+     * @returns {Promise<string> | string} The type of the object.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/type-handling/getting-object-type)
      * @method
      */
@@ -408,7 +421,9 @@ class InvocationContext {
             this.#connectionData,
             this.#buildCommand(localCommand)
         )
-        const result = invocationContext.execute().getValue()
+        /** @type {InvocationContext} */
+        const execCtx = /** @type {any} */ (invocationContext.execute())
+        const result = execCtx.getValue()
         return /** @type {string} */ (result)
     }
 
@@ -424,39 +439,36 @@ class InvocationContext {
 
     /**
      * Retrieves an array from the target runtime.
-     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to retrieve the array.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/arrays-and-collections/retrieve-array)
+     * @returns {Promise<any[]>}
      * @method
      */
     retrieveArray() {
-        let localCommand = new Command(this.#runtimeName, CommandType.RetrieveArray, [])
-        let localInvCtx = new InvocationContext(
+        const localCommand = new Command(this.#runtimeName, CommandType.RetrieveArray, [])
+        const localInvCtx = new InvocationContext(
             this.#runtimeName,
             this.#connectionData,
             this.#buildCommand(localCommand)
         )
-        localInvCtx.execute()
 
-        if (localInvCtx.#responseCommand === null) {
-            throw new Error('responseCommand is undefined in Invocation Context execute method')
+        localInvCtx.execute() // Promise<InvocationContext> | InvocationContext
+
+        const extract = (/** @type {Command} */ respCommand) => {
+            return respCommand.payload
         }
-        return localInvCtx.#responseCommand.payload
+
+        // Normalize to Promise
+        return localInvCtx.#responseCommand instanceof Promise ? localInvCtx.#responseCommand.then(extract) : localInvCtx.#responseCommand?.payload
     }
 
     /**
      * Returns the primitive value from the target runtime. This could be any primitive type in JavaScript,
      * such as int, boolean, byte, char, long, double, float, etc.
-     * @returns {Command} The value of the current command.
+     * @returns {unknown} The value of the current command.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
      * @method
      */
-
-    /**
-     * @returns {unknown}
-     */
     getValue() {
-        this.#resultValue = this.#currentCommand?.payload[0]
-        return this.#resultValue
+        return this.#currentCommand?.payload[0]
     }
 
     /**
@@ -522,8 +534,6 @@ class InvocationWsContext extends InvocationContext {
     #interpreter
     /** @type {boolean} */
     #isExecuted
-    /** @type {any | null} */
-    #resultValue
 
     /**
      * @param {RuntimeNameType} runtimeName
@@ -540,7 +550,6 @@ class InvocationWsContext extends InvocationContext {
         this.#responseCommand = null
         this.#isExecuted = isExecuted
         this.#interpreter = null
-        this.#resultValue = null
     }
 
     /**
@@ -555,7 +564,6 @@ class InvocationWsContext extends InvocationContext {
      * @async
      * @method
      */
-    // @ts-expect-error
     async execute() {
         if (this.#currentCommand === null) {
             throw new Error('currentCommand is undefined in Invocation Context execute method')
@@ -591,7 +599,6 @@ class InvocationWsContext extends InvocationContext {
      * @async
      * @method
      */
-    // @ts-expect-error
     async getResultType() {
         const localCommand = new Command(this.#runtimeName, CommandType.GetResultType, [])
         const invocationContext = new InvocationWsContext(