javonet-nodejs-sdk 2.5.7 → 2.5.9

package/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/lib/core/transmitter/TransmitterWrapper.js

@@ -1,14 +1,20 @@
-let library;
+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`)
+        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, '../../../')}`)
+            library = require(
+                `${require('path').resolve(__dirname, '../../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`
+            )
+        let binariesRootPath = String(`${require('path').resolve(__dirname, '../../../../')}`)
         return library.initializeTransmitter(binariesRootPath)
     }
 

package/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/lib/core/webSocketClient/WebSocketClient.js

@@ -1,4 +1,4 @@
-const WebSocket = require('ws');
+const WebSocket = require('ws')
 
 /**
  * Enum for WebSocket states.
@@ -6,128 +6,126 @@ const WebSocket = require('ws');
  * @enum {string}
  */
 const WebSocketStateEnum = {
-  OPEN: 'open',
-  CLOSE: 'close',
-  ERROR: 'error',
-};
+    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}
+     * @param {string} url
+     * @param {object} options
      */
-    this.url = url;
+    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
+    }
 
     /**
-     * @type {WebSocket | null}
+     * Sends messageArray through websocket connection
+     * @async
+     * @param {Buffer|ArrayBuffer|Buffer[]} messageArray
+     * @returns {Promise<Buffer|ArrayBuffer|Buffer[]>}
      */
-    this.instance = null;
+    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)
+            }
+        })
+    }
 
     /**
-     * @type {boolean} isConnected indicates whether the WebSocket is connected.
+     * Disconnects the WebSocket by terminating the connection.
      */
-    this.isConnected = false;
+    disconnect() {
+        if (this.instance) {
+            this.instance.terminate()
+        }
+        this.isConnected = false
+    }
 
     /**
-     * @type {boolean}
+     * Connects to the WebSocket server.
+     * @private
+     * @async
+     * @returns {Promise<void>} - A promise that resolves when the connection is established.
      */
-    this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? false;
-  }
-
-  /**
-   * Sends data through websocket connection
-   * @async
-   * @param {Buffer|ArrayBuffer|Buffer[]} data
-   * @returns {Promise<Buffer|ArrayBuffer|Buffer[]>}
-   */
-  send(data) {
-    return new Promise((resolve, reject) => {
-      try {
-        if (this.isConnected) {
-          this._sendMessage(data, resolve, reject);
-        } else {
-          this._connect().then(() => {
-            this._sendMessage(data, resolve, reject);
-          });
-        }
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-  
-  /**
-   * Disconnects the WebSocket by terminating the connection.
-   */
-  disconnect() {
-    if (this.instance) {
-      this.instance.terminate();
+    _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)
+        })
     }
-    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, () => {
-        console.log('[WebSocketClient] connected');
-        this.isConnected = true;
-        resolve();
-      });
-
-      this.instance.on(WebSocketStateEnum.ERROR, (error) => {
-        console.log('[WebSocketClient] error', error);
-        reject(error);
-      });
-
-      this.instance.on(WebSocketStateEnum.CLOSE, () => {
-        console.log('[WebSocketClient] closed');
-        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 }
+module.exports = WebSocketClient

package/lib/sdk/ConfigRuntimeFactory.js

@@ -1,13 +1,14 @@
-const RuntimeContext = require("./RuntimeContext")
-const JsonFileResolver = require("./tools/JsonFileResolver")
-const Runtime = require("../utils/RuntimeName")
-const RuntimeNameHandler = require("../utils/RuntimeNameHandler")
-const InMemoryConnectionData = require("../utils/connectionData/InMemoryConnectionData");
-const TcpConnectionData = require("../utils/connectionData/TcpConnectionData")
-const WsConnectionData = require("../utils/connectionData/WsConnectionData")
-const Transmitter = require("../core/transmitter/Transmitter");
-
-
+const JsonFileResolver = require('./tools/JsonFileResolver')
+const Transmitter = require('../core/transmitter/Transmitter')
+
+const {
+    RuntimeName,
+    RuntimeNameHandler,
+    InMemoryConnectionData,
+    WsConnectionData,
+    RuntimeContext,
+} = require('@javonet/core')
+const TcpConnectionData = require('../utils/connectionData/TcpConnectionData')
 
 /**
  * The ConfigRuntimeFactory class provides methods for creating runtime contexts.
@@ -26,8 +27,8 @@ class ConfigRuntimeFactory {
      * @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(Runtime.Clr, configName)
+    clr(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Clr, configName)
     }
 
     /**
@@ -36,8 +37,8 @@ class ConfigRuntimeFactory {
      * @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(Runtime.Jvm, configName)
+    jvm(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Jvm, configName)
     }
 
     /**
@@ -46,8 +47,8 @@ class ConfigRuntimeFactory {
      * @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(Runtime.Netcore, configName)
+    netcore(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Netcore, configName)
     }
 
     /**
@@ -56,8 +57,8 @@ class ConfigRuntimeFactory {
      * @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(Runtime.Perl, configName)
+    perl(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Perl, configName)
     }
 
     /**
@@ -66,8 +67,8 @@ class ConfigRuntimeFactory {
      * @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(Runtime.Python, configName)
+    python(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Python, configName)
     }
 
     /**
@@ -76,8 +77,8 @@ class ConfigRuntimeFactory {
      * @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(Runtime.Ruby, configName)
+    ruby(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Ruby, configName)
     }
 
     /**
@@ -86,55 +87,59 @@ class ConfigRuntimeFactory {
      * @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(Runtime.Nodejs, configName)
+    nodejs(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Nodejs, configName)
     }
 
-    #getRuntimeContext(runtime, configName = "default") {
-        let jfr = new JsonFileResolver(this.path);
+    #getRuntimeContext(runtime, configName = 'default') {
+        let jfr = new JsonFileResolver(this.path)
 
         try {
-            let licenseKey = jfr.getLicenseKey();
-            Transmitter.activateWithCredentials(licenseKey);
+            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));
+        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);
+            throw new Error('Unsupported connection type: ' + connType)
         }
 
-        rtmCtx = RuntimeContext.getInstance(runtime, connData);
-        this.#loadModules(runtime, configName, jfr, rtmCtx);
-        return rtmCtx;
+        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)
+        const modules = jfr
+            .getModules(RuntimeNameHandler.getName(runtime), configName)
             .split(';')
-            .filter(module => module.trim() !== '');
+            .filter((module) => module.trim() !== '')
 
-        const configDirectoryAbsolutePath = require('path').dirname(this.path);
+        const configDirectoryAbsolutePath = require('path').dirname(this.path)
 
-        modules.forEach(module => {
+        modules.forEach((module) => {
             if (require('path').isAbsolute(module)) {
-                rtmCtx.loadLibrary(module);
+                rtmCtx.loadLibrary(module)
             } else {
-                rtmCtx.loadLibrary(require('path').join(configDirectoryAbsolutePath, module));
+                rtmCtx.loadLibrary(require('path').join(configDirectoryAbsolutePath, module))
             }
-        });
+        })
     }
-
 }
 
-module.exports = ConfigRuntimeFactory
+module.exports = ConfigRuntimeFactory

package/lib/sdk/Javonet.js

@@ -1,17 +1,9 @@
-const RuntimeFactory = require("./RuntimeFactory");
-const ConfigRuntimeFactory = require("./ConfigRuntimeFactory");
-const Transmitter = require("../core/transmitter/Transmitter");
-const InMemoryConnectionData = require("../utils/connectionData/InMemoryConnectionData");
-const TcpConnectionData = require("../utils/connectionData/TcpConnectionData");
-const WsConnectionData = require("../utils/connectionData/WsConnectionData");
-const SDKExceptionHelper = require("./tools/SdkExceptionHelper")
-const RuntimeLogger = require("../utils/RuntimeLogger");
-
-
-//static constructor not supported in nodeJS 12.20
-Transmitter.initialize()
-//SDKExceptionHelper.sendExceptionToAppInsights("SdkMessage", "Javonet SDK initialized");
+const { RuntimeFactory, InMemoryConnectionData, WsConnectionData } = require('@javonet/core')
 
+const Transmitter = require('../core/transmitter/Transmitter')
+const ConfigRuntimeFactory = require('./ConfigRuntimeFactory')
+const RuntimeLogger = require('../utils/RuntimeLogger')
+const TcpConnectionData = require('../utils/connectionData/TcpConnectionData')
 
 /**
  * The Javonet class is a singleton class that serves as the entry point for interacting with Javonet.
@@ -20,13 +12,19 @@ Transmitter.initialize()
  * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/javonet-static-class)
  */
 class Javonet {
+    // Static block to initialize the Transmitter
+    static {
+        Transmitter.initialize()
+        //SDKExceptionHelper.sendExceptionToAppInsights("SdkMessage", "Javonet SDK initialized");
+    }
+
     /**
      * Initializes Javonet using an in-memory channel on the same machine.
      * @returns {RuntimeFactory} A RuntimeFactory instance configured for an in-memory connection.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/in-memory-channel)
      */
     static inMemory() {
-        return new RuntimeFactory(new InMemoryConnectionData());
+        return new RuntimeFactory(new InMemoryConnectionData())
     }
 
     /**
@@ -36,17 +34,17 @@ class Javonet {
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/tcp-channel)
      */
     static tcp(tcpConnectionData) {
-        return new RuntimeFactory(tcpConnectionData);
+        return new RuntimeFactory(tcpConnectionData)
     }
 
     /**
      * Initializes Javonet with a WebSocket connection to a remote machine.
-     * @param wsConnectionData - The WebSocket connection data of the remote machine.
+     * @param {WsConnectionData} wsConnectionData - The WebSocket connection data of the remote machine.
      * @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) {
-        return new RuntimeFactory(wsConnectionData);
+        return new RuntimeFactory(wsConnectionData)
     }
 
     /**
@@ -57,12 +55,7 @@ class Javonet {
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/configure-channel)
      */
     static withConfig(configPath) {
-        try {
-            return new ConfigRuntimeFactory(configPath);
-        } catch (error) {
-            //SDKExceptionHelper.sendExceptionToAppInsights(error, "unknown");
-            throw error;
-        }
+        return new ConfigRuntimeFactory(configPath)
     }
 
     /**
@@ -72,22 +65,25 @@ class Javonet {
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/getting-started/activating-javonet)
      */
     static activate(licenseKey) {
-        try {
-            return Transmitter.activate(licenseKey);
-        } catch (error) {
-            //SDKExceptionHelper.sendExceptionToAppInsights(error, licenseKey);
-            throw error;
-        }
-
+        return Transmitter.activate(licenseKey)
     }
 
     static getRuntimeInfo() {
         return RuntimeLogger.getRuntimeInfo()
     }
+
+    /**
+     * Sets the configuration source for the Javonet SDK.
+     *
+     * @param {string} configSource - The configuration source.
+     */
+    static setConfigSource(configSource) {
+        Transmitter.setConfigSource(configSource)
+    }
 }
 
 module.exports = {
     Javonet,
     TcpConnectionData,
-    WsConnectionData
-};
+    WsConnectionData,
+}