javonet-nodejs-sdk 2.5.8 → 2.5.9

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