javonet-nodejs-sdk 2.5.8 → 2.5.10

package/Binaries/Nodejs/{core → lib/core}/protocol/TypeSerializer.js

@@ -1,27 +1,26 @@
 const Command = require('../../utils/Command')
 const Type = require('../../utils/Type')
 const StringEncodingMode = require('../../utils/StringEncodingMode')
+const { Buffer } = require('buffer')
 
-const util = require('util');
-let encoder = new util.TextEncoder();
+const encoder = new TextEncoder()
 
 class TypeSerializer {
-
     static encodePrimitive(payload_item) {
         if (payload_item === null) {
             return TypeSerializer.serializeNull()
         }
         if (payload_item instanceof Command) {
             return TypeSerializer.serializeCommand(payload_item)
-        } else if (typeof (payload_item) === 'number' || payload_item instanceof Number) {
+        } else if (typeof payload_item === 'number' || payload_item instanceof Number) {
             if (Number.isInteger(payload_item)) {
                 return TypeSerializer.serializeInt(payload_item)
             } else {
                 return TypeSerializer.serializeDouble(payload_item)
             }
-        } else if (typeof (payload_item) === 'string' || payload_item instanceof String) {
+        } else if (typeof payload_item === 'string' || payload_item instanceof String) {
             return TypeSerializer.serializeString(payload_item)
-        } else if (typeof (payload_item) === 'boolean' || payload_item instanceof Boolean) {
+        } else if (typeof payload_item === 'boolean' || payload_item instanceof Boolean) {
             return TypeSerializer.serializeBool(payload_item)
         } else {
             throw 'Unknown type - not supported in JavaScript'
@@ -134,4 +133,4 @@ class TypeSerializer {
     }
 }
 
-module.exports = TypeSerializer
+module.exports = TypeSerializer

package/Binaries/Nodejs/lib/core/receiver/Receiver.js

@@ -0,0 +1,32 @@
+const { InMemoryConnectionData, CommandSerializer, Interpreter } = require('../../..')
+
+let RuntimeLogger
+
+class Receiver {
+    static connectionData = new InMemoryConnectionData()
+    Receiver() {
+        if (!RuntimeLogger) {
+            RuntimeLogger = require('../../utils/RuntimeLogger')
+        }
+        RuntimeLogger.printRuntimeInfo()
+    }
+
+    /**
+     * @param {number[]} messageByteArray
+     */
+    static sendCommand(messageByteArray) {
+        return new CommandSerializer().serialize(
+            new Interpreter().process(messageByteArray),
+            this.connectionData
+        )
+    }
+
+    static heartBeat(messageByteArray) {
+        let response = new Int8Array(2)
+        response[0] = messageByteArray[11]
+        response[1] = messageByteArray[12] - 2
+        return response
+    }
+}
+
+module.exports = Receiver

package/Binaries/Nodejs/{core → lib/core}/receiver/ReceiverNative.js

@@ -1,8 +1,8 @@
-const Receiver = require('./Receiver') 
+const Receiver = require('./Receiver')
 
 class ReceiverNative {
     static sendCommand(messageByteArray) {
-		return Receiver.sendCommand(messageByteArray)
+        return Receiver.sendCommand(messageByteArray)
     }
 
     static heartBeat(messageByteArray) {
@@ -10,4 +10,4 @@ class ReceiverNative {
     }
 }
 
-global.ReceiverNative = ReceiverNative;
+global.ReceiverNative = ReceiverNative

package/Binaries/Nodejs/{core → lib/core}/referenceCache/ReferencesCache.js

@@ -1,9 +1,9 @@
+const v4 = require('../../utils/uuid/v4')
+
 let _cache = {}
 let _instance = null
-const v4 = require('../../utils/uuid/v4')
 
 class ReferencesCache {
-
     static getInstance() {
         if (_instance === null) {
             _instance = new ReferencesCache()
@@ -23,8 +23,8 @@ class ReferencesCache {
 
     deleteReference(referenceGuid) {
         delete _cache[referenceGuid]
-        return 0;
+        return 0
     }
 }
 
-module.exports = ReferencesCache
+module.exports = ReferencesCache

package/Binaries/Nodejs/{core → lib/core}/transmitter/Transmitter.js

@@ -1,16 +1,15 @@
 const wrapper = require('./TransmitterWrapper')
 
 class Transmitter {
-
     static initialize() {
         return wrapper.initialize()
     }
 
-   static sendCommand(messageArray) {
+    static sendCommand(messageArray) {
         return wrapper.sendCommand(messageArray)
     }
 
-    static activate = function(licenseKey) {
+    static activate = function (licenseKey) {
         return wrapper.activate(licenseKey)
     }
 

package/Binaries/Nodejs/lib/core/transmitter/TransmitterWebsocket.js

@@ -0,0 +1,33 @@
+const WebSocketClient = require('../webSocketClient/WebSocketClient')
+
+/** @typedef {import('../../../../core/lib/declarations').WsConnectionData} WsConnectionData */
+
+class TransmitterWebsocket {
+    /**
+     * @returns {void}
+     */
+    static initialize() {}
+
+    /**
+     * @returns {void}
+     */
+    static setConfigSource() {}
+
+    /**
+     * @returns {void}
+     */
+    static activate() {}
+
+    /**
+     * @async
+     * @param {number[]} messageByteArray
+     * @param {WsConnectionData} connectionData
+     * @returns {Promise<number[]>} responseByteArray
+     */
+    static async sendCommand(messageByteArray, connectionData) {
+        const { hostname } = connectionData
+        return new WebSocketClient(hostname).send(messageByteArray)
+    }
+}
+
+module.exports = TransmitterWebsocket

package/Binaries/Nodejs/lib/core/transmitter/TransmitterWrapper.js

@@ -0,0 +1,34 @@
+let library
+
+class TransmitterWrapper {
+    static initialize() {
+        if (process.platform === 'win32')
+            library = require(
+                `${require('path').resolve(__dirname, '../../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`
+            )
+        else if (process.platform === 'darwin')
+            library = require(
+                `${require('path').resolve(__dirname, '../../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`
+            )
+        else
+            library = require(
+                `${require('path').resolve(__dirname, '../../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`
+            )
+        let binariesRootPath = String(`${require('path').resolve(__dirname, '../../../../')}`)
+        return library.initializeTransmitter(binariesRootPath)
+    }
+
+    static activate(licenseKey) {
+        return library.activate(licenseKey)
+    }
+
+    static sendCommand(messageArray) {
+        return library.sendCommand(messageArray)
+    }
+
+    static setConfigSource(configSource) {
+        return library.setConfigSource(configSource)
+    }
+}
+
+module.exports = TransmitterWrapper

package/Binaries/Nodejs/{core → lib/core}/typeCache/TypeCache.js

@@ -1,39 +1,39 @@
 class TypeCache {
-    static _instance = null;
-    typeCache = [];
+    static _instance = null
+    typeCache = []
 
     constructor() {
         if (TypeCache._instance === null) {
-            TypeCache._instance = this;
+            TypeCache._instance = this
         }
-        return TypeCache._instance;
+        return TypeCache._instance
     }
 
     cacheType(typRegex) {
-        this.typeCache.push(typRegex);
+        this.typeCache.push(typRegex)
     }
 
     isTypeCacheEmpty() {
-        return this.typeCache.length === 0;
+        return this.typeCache.length === 0
     }
 
     isTypeAllowed(typeToCheck) {
         for (let pattern of this.typeCache) {
             if (new RegExp(pattern).test(typeToCheck.name)) {
-                return true;
+                return true
             }
         }
-        return false;
+        return false
     }
 
     getCachedTypes() {
-        return this.typeCache;
+        return this.typeCache
     }
 
     clearCache() {
-        this.typeCache = [];
-        return 0;
+        this.typeCache = []
+        return 0
     }
 }
 
-module.exports = TypeCache;
+module.exports = TypeCache

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

@@ -0,0 +1,131 @@
+const WebSocket = require('ws')
+
+/**
+ * Enum for WebSocket states.
+ * @readonly
+ * @enum {string}
+ */
+const WebSocketStateEnum = {
+    OPEN: 'open',
+    CLOSE: 'close',
+    ERROR: 'error',
+}
+
+/**
+ * WebSocketClient class that handles WebSocket connection, message sending, and automatic disconnection.
+ */
+class WebSocketClient {
+    /**
+     * @param {string} url
+     * @param {object} options
+     */
+    constructor(url, options) {
+        /**
+         * @type {string}
+         */
+        this.url = url
+
+        /**
+         * @type {WebSocket | null}
+         */
+        this.instance = null
+
+        /**
+         * @type {boolean} isConnected indicates whether the WebSocket is connected.
+         */
+        this.isConnected = false
+
+        /**
+         * @type {boolean}
+         */
+        this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? false
+    }
+
+    /**
+     * Sends messageArray through websocket connection
+     * @async
+     * @param {Buffer|ArrayBuffer|Buffer[]} messageArray
+     * @returns {Promise<Buffer|ArrayBuffer|Buffer[]>}
+     */
+    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) {
+                reject(error)
+            }
+        })
+    }
+
+    /**
+     * Disconnects the WebSocket by terminating the connection.
+     */
+    disconnect() {
+        if (this.instance) {
+            this.instance.terminate()
+        }
+        this.isConnected = false
+    }
+
+    /**
+     * Connects to the WebSocket server.
+     * @private
+     * @async
+     * @returns {Promise<void>} - A promise that resolves when the connection is established.
+     */
+    _connect() {
+        return new Promise((resolve, reject) => {
+            this.instance = new WebSocket(this.url)
+
+            this.instance.on(WebSocketStateEnum.OPEN, () => {
+                this.isConnected = true
+                resolve()
+            })
+
+            // eslint-disable-next-line no-unused-vars
+            this.instance.on(WebSocketStateEnum.ERROR, (error) => {
+                reject(null)
+            })
+
+            this.instance.on(WebSocketStateEnum.CLOSE, () => {
+                this.isConnected = false
+            })
+        })
+    }
+
+    /**
+     * 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/declarations.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Represents WebSocket connection data.
+ */
+export class WsConnectionData {
+    /**
+     * Constructs a new WsConnectionData instance.
+     * @param hostname - The hostname of the connection.
+     */
+    constructor(hostname: string)
+
+    readonly connectionType: any
+
+    /** The hostname of the connection. */
+    hostname: any
+
+    /**
+     * Serializes the connection data.
+     * @returns An array of connection data values.
+     */
+    serializeConnectionData(): number[]
+
+    /**
+     * Checks equality with another WsConnectionData object.
+     * @param other - The object to compare with.
+     * @returns `true` if equal, otherwise `false`.
+     */
+    equals(other: any): boolean
+}
+
+declare enum RuntimeName {
+    Clr = 0,
+    Go = 1,
+    Jvm = 2,
+    Netcore = 3,
+    Perl = 4,
+    Python = 5,
+    Ruby = 6,
+    Nodejs = 7,
+    Cpp = 8,
+}
+
+interface RuntimeChannel {
+    type: 'inMemory' | 'tcp' | 'webSocket'
+    host?: string
+    port?: number
+}
+
+interface Runtime {
+    name: string
+    customOptions: string
+    modules: string
+    channel: RuntimeChannel
+    runtimeName: RuntimeName
+}
+
+type Runtimes = {
+    [Key in keyof typeof RuntimeName]: Runtime[]
+}
+
+export interface ConfigSource {
+    [key: string]: any
+    licenseKey: string
+    runtimes: Partial<Runtimes>
+}

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

@@ -0,0 +1,145 @@
+const JsonFileResolver = require('./tools/JsonFileResolver')
+const Transmitter = require('../core/transmitter/Transmitter')
+
+const {
+    RuntimeName,
+    RuntimeNameHandler,
+    InMemoryConnectionData,
+    WsConnectionData,
+    RuntimeContext,
+} = require('../..')
+const TcpConnectionData = require('../utils/connectionData/TcpConnectionData')
+
+/**
+ * The ConfigRuntimeFactory class provides methods for creating runtime contexts.
+ * Each method corresponds to a specific runtime (CLR, JVM, .NET Core, Perl, Ruby, Node.js, Python) and returns a RuntimeContext instance for that runtime.
+ * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+ */
+class ConfigRuntimeFactory {
+    constructor(path) {
+        this.path = path
+        Transmitter.setConfigSource(path)
+    }
+
+    /**
+     * Creates RuntimeContext instance to interact with the .NET Framework runtime.
+     * @param {string} [configName="default"] - The name of the configuration to use (optional).
+     * @return {RuntimeContext} a RuntimeContext instance for the .NET Framework runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    clr(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Clr, configName)
+    }
+
+    /**
+     * Creates RuntimeContext instance to interact with the JVM runtime.
+     * @param {string} [configName="default"] - The name of the configuration to use (optional).
+     * @return {RuntimeContext} a RuntimeContext instance for the JVM runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    jvm(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Jvm, configName)
+    }
+
+    /**
+     * Creates RuntimeContext instance to interact with the .NET runtime.
+     * @param {string} [configName="default"] - The name of the configuration to use (optional).
+     * @return {RuntimeContext} a RuntimeContext instance for the .NET runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    netcore(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Netcore, configName)
+    }
+
+    /**
+     * Creates RuntimeContext instance to interact with the Perl runtime.
+     * @param {string} [configName="default"] - The name of the configuration to use (optional).
+     * @return {RuntimeContext} a RuntimeContext instance for the Perl runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    perl(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Perl, configName)
+    }
+
+    /**
+     * Creates RuntimeContext instance to interact with the Python runtime.
+     * @param {string} [configName="default"] - The name of the configuration to use (optional).
+     * @return {RuntimeContext} a RuntimeContext instance for the Python runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    python(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Python, configName)
+    }
+
+    /**
+     * Creates RuntimeContext instance to interact with the Ruby runtime.
+     * @param {string} [configName="default"] - The name of the configuration to use (optional).
+     * @return {RuntimeContext} a RuntimeContext instance for the Ruby runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    ruby(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Ruby, configName)
+    }
+
+    /**
+     * Creates RuntimeContext instance to interact with Node.js runtime.
+     * @param {string} [configName="default"] - The name of the configuration to use (optional).
+     * @return {RuntimeContext} a RuntimeContext instance for the Node.js runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    nodejs(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Nodejs, configName)
+    }
+
+    #getRuntimeContext(runtime, configName = 'default') {
+        let jfr = new JsonFileResolver(this.path)
+
+        try {
+            let licenseKey = jfr.getLicenseKey()
+            Transmitter.activateWithCredentials(licenseKey)
+            // eslint-disable-next-line no-unused-vars
+        } catch (error) {
+            // licenseKey not found - do nothing
+        }
+        let rtmCtx = null
+        let connData = null
+        let connType = jfr.getChannelType(RuntimeNameHandler.getName(runtime), configName)
+        if (connType === 'inMemory') {
+            connData = new InMemoryConnectionData()
+        } else if (connType === 'tcp') {
+            connData = new TcpConnectionData(
+                jfr.getChannelHost(RuntimeNameHandler.getName(runtime), configName),
+                jfr.getChannelPort(RuntimeNameHandler.getName(runtime), configName)
+            )
+        } else if (connType === 'webSocket') {
+            connData = new WsConnectionData(
+                jfr.getChannelHost(RuntimeNameHandler.getName(runtime), configName)
+            )
+        } else {
+            throw new Error('Unsupported connection type: ' + connType)
+        }
+
+        rtmCtx = RuntimeContext.getInstance(runtime, connData)
+        this.#loadModules(runtime, configName, jfr, rtmCtx)
+        return rtmCtx
+    }
+
+    #loadModules(runtime, configName, jfr, rtmCtx) {
+        const modules = jfr
+            .getModules(RuntimeNameHandler.getName(runtime), configName)
+            .split(';')
+            .filter((module) => module.trim() !== '')
+
+        const configDirectoryAbsolutePath = require('path').dirname(this.path)
+
+        modules.forEach((module) => {
+            if (require('path').isAbsolute(module)) {
+                rtmCtx.loadLibrary(module)
+            } else {
+                rtmCtx.loadLibrary(require('path').join(configDirectoryAbsolutePath, module))
+            }
+        })
+    }
+}
+
+module.exports = ConfigRuntimeFactory