javonet-nodejs-sdk 2.5.16 → 2.5.18

package/lib/core/transmitter/TransmitterWebsocket.js

@@ -1,5 +1,9 @@
+// @ts-check
 import { WebSocketClient } from '../webSocketClient/WebSocketClient.js'
 
+/**
+ * @typedef {import('../../utils/connectionData/IConnectionData.js').IConnectionData} IConnectionData
+ */
 export class TransmitterWebsocket {
     /**
      * @returns {void}
@@ -18,12 +22,15 @@ export class TransmitterWebsocket {
 
     /**
      * @async
-     * @param {number[]} messageByteArray
-     * @param {WsConnectionData} connectionData
-     * @returns {Promise<number[]>} responseByteArray
+     * @param {Int8Array} messageByteArray
+     * @param {IConnectionData} connectionData
+     * @returns {Promise<Int8Array>} responseByteArray
      */
-    static async sendCommand(messageByteArray, connectionData) {
+    static sendCommand(messageByteArray, connectionData) {
         const { hostname } = connectionData
-        return new WebSocketClient(hostname).send(messageByteArray)
+        const options = {
+            isDisconnectedAfterMessage: true,
+        }
+        return new WebSocketClient(hostname, options).send(messageByteArray)
     }
 }

package/lib/core/transmitter/TransmitterWebsocketBrowser.js

@@ -2,10 +2,8 @@
 import { WebSocketClientBrowser } from '../webSocketClient/WebSocketClientBrowser.js'
 
 /**
- * @typedef {object} ConnectionData
- * @property {string} hostname
+ * @typedef {import('../../utils/connectionData/IConnectionData.js').IConnectionData} IConnectionData
  */
-
 export class TransmitterWebsocketBrowser {
     /**
      * @returns {void}
@@ -20,7 +18,7 @@ export class TransmitterWebsocketBrowser {
     /**
      * @async
      * @param {Int8Array} messageByteArray
-     * @param {ConnectionData} connectionData
+     * @param {IConnectionData} connectionData
      * @returns {Promise<Int8Array>} responseByteArray
      */
     static async sendCommand(messageByteArray, connectionData) {

package/lib/core/transmitter/TransmitterWrapper.js

@@ -1,14 +1,18 @@
+// @ts-check
 import { getDependency, getRequire, isNodejsRuntime } from '../../utils/Runtime.js'
 import { ReceiverNative } from '../receiver/ReceiverNative.js'
 
-let library
+/** @type {any | null} */
+let library = null
+/** @type {any | null} */
+let path = null
 
 /** @type {import('module').createRequire} */
 const requireDynamic = getRequire(import.meta.url)
 
 class TransmitterWrapper {
     static isNativeLibraryLoaded() {
-        return library !== undefined
+        return Boolean(library)
     }
 
     static loadNativeLibrary() {
@@ -19,38 +23,55 @@ class TransmitterWrapper {
             return
         }
         try {
-            const path = requireDynamic('path')
+            if (!path) {
+                path = requireDynamic('path')
+            }
             const packagePath = getDependency('javonet-binaries', import.meta.url)
 
             const binariesRootPath = path.dirname(packagePath)
-            const nativeAddonPath = path.join(binariesRootPath, 'build', 'Release', 'JavonetNodejsRuntimeAddon.node')
+            const nativeAddonPath = path.join(
+                binariesRootPath,
+                'build',
+                'Release',
+                'JavonetNodejsRuntimeAddon.node'
+            )
 
             library = requireDynamic(nativeAddonPath)
             library.initializeTransmitter(binariesRootPath)
-            library.setReceiverNative(global.ReceiverNative)
+            // @ts-expect-error
+            library.setReceiverNative(global?.ReceiverNative)
         } catch (error) {
             throw error
         }
     }
 
     /**
-     * @param {string} licenseKey 
+     * @param {string} licenseKey
      */
     static activate(licenseKey) {
         this.loadNativeLibrary()
         return library.activate(licenseKey)
     }
 
+    /**
+     * @param {Int8Array} messageArray
+     */
     static sendCommand(messageArray) {
         this.loadNativeLibrary()
         return library.sendCommand(messageArray)
     }
 
+    /**
+     * @param {string} configSource
+     */
     static setConfigSource(configSource) {
         this.loadNativeLibrary()
         return library.setConfigSource(configSource)
     }
 
+    /**
+     * @param {string} path
+     */
     static setJavonetWorkingDirectory(path) {
         this.loadNativeLibrary()
         library.setJavonetWorkingDirectory(path)

package/lib/core/typeCache/TypeCache.js

@@ -1,5 +1,8 @@
+// @ts-check
 class TypeCache {
+    /** @type {TypeCache | null} */
     static _instance = null
+    /** @type {string[]} */
     typeCache = []
 
     constructor() {
@@ -9,6 +12,9 @@ class TypeCache {
         return TypeCache._instance
     }
 
+    /**
+     * @param {string} typRegex
+     */
     cacheType(typRegex) {
         this.typeCache.push(typRegex)
     }
@@ -17,6 +23,9 @@ class TypeCache {
         return this.typeCache.length === 0
     }
 
+    /**
+     * @param {{ name: string }} typeToCheck
+     */
     isTypeAllowed(typeToCheck) {
         for (let pattern of this.typeCache) {
             if (new RegExp(pattern).test(typeToCheck.name)) {

package/lib/core/webSocketClient/WebSocketClient.js

@@ -1,7 +1,11 @@
+//@ts-check
 import { getRequire, isNodejsRuntime } from '../../utils/Runtime.js'
 
 const requireDynamic = getRequire(import.meta.url)
 
+/** @typedef {import('ws').WebSocket} wsClient */
+/** @typedef {typeof import('ws').WebSocket} WebSocketClass */
+
 /**
  * Enum for WebSocket states.
  * @readonly
@@ -13,6 +17,7 @@ const WebSocketStateEnum = {
     ERROR: 'error',
 }
 
+/** @type {WebSocketClass | null} */
 let WebSocket = null
 
 /**
@@ -21,34 +26,23 @@ let WebSocket = null
 class WebSocketClient {
     /**
      * @param {string} url
-     * @param {object} options
+     * @param {{ isDisconnectedAfterMessage: boolean }} options
      */
     constructor(url, options) {
-        /**
-         * @type {string}
-         */
+        /** @type {string} */
         this.url = url
-
-        /**
-         * @type {WebSocket | null}
-         */
+        /** @type {wsClient | null} */
         this.instance = null
-
-        /**
-         * @type {boolean} isConnected indicates whether the WebSocket is connected.
-         */
+        /** @type {boolean} */
         this.isConnected = false
-
-        /**
-         * @type {boolean}
-         */
+        /** @type {boolean} */
         this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? true
     }
 
     /**
      * Connects to the WebSocket server.
      * @async
-     * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
+     * @returns {Promise<wsClient>} - A promise that resolves when the connection is established.
      */
     async connect() {
         if (!WebSocket) {
@@ -56,7 +50,12 @@ class WebSocketClient {
                 try {
                     WebSocket = requireDynamic('ws')
                 } catch (error) {
-                    if (error.code === 'MODULE_NOT_FOUND') {
+                    if (
+                        typeof error === 'object' &&
+                        error &&
+                        'code' in error &&
+                        error.code === 'MODULE_NOT_FOUND'
+                    ) {
                         throw new Error('ws module not found. Please install it using npm install ws')
                     }
                     throw error
@@ -65,6 +64,10 @@ class WebSocketClient {
         }
 
         return new Promise((resolve, reject) => {
+            if (!WebSocket) {
+                reject(new Error('ws client is null'))
+                return
+            }
             const client = new WebSocket(this.url)
 
             client.on(WebSocketStateEnum.OPEN, () => {
@@ -73,7 +76,7 @@ class WebSocketClient {
             })
 
             // eslint-disable-next-line no-unused-vars
-            client.on(WebSocketStateEnum.ERROR, (error) => {
+            client.on(WebSocketStateEnum.ERROR, (/** @type {unknown} */ error) => {
                 reject(error)
             })
 
@@ -86,20 +89,16 @@ class WebSocketClient {
     /**
      * Sends messageArray through websocket connection
      * @async
-     * @param {Buffer|ArrayBuffer|Buffer[]} messageArray
-     * @returns {Promise<Buffer|ArrayBuffer|Buffer[]>}
+     * @param {Int8Array} messageArray
+     * @returns {Promise<Int8Array>}
      */
     send(messageArray) {
         return new Promise((resolve, reject) => {
             ;(this.instance ? Promise.resolve(this.instance) : this._connect())
                 .then((client) => {
-                    client.send(messageArray, (err) => {
-                        if (err) {
-                            reject(err)
-                        }
-                    })
+                    client.send(/** @type {any} */ (messageArray))
 
-                    client.on('message', (message) => {
+                    client.on('message', (/** @type {any} */ message) => {
                         resolve(message)
 
                         if (this.isDisconnectedAfterMessage) {
@@ -128,7 +127,7 @@ class WebSocketClient {
      * Connects to the WebSocket server.
      * @private
      * @async
-     * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
+     * @returns {Promise<wsClient>} - A promise that resolves when the connection is established.
      */
     _connect() {
         if (!WebSocket) {
@@ -136,7 +135,7 @@ class WebSocketClient {
                 try {
                     WebSocket = requireDynamic('ws')
                 } catch (error) {
-                    if (error.code === 'MODULE_NOT_FOUND') {
+                    if (/** @type {{ code?: string }} */ (error).code === 'MODULE_NOT_FOUND') {
                         throw new Error('ws module not found. Please install it using npm install ws')
                     }
                     throw error
@@ -145,6 +144,10 @@ class WebSocketClient {
         }
 
         return new Promise((resolve, reject) => {
+            if (!WebSocket) {
+                reject(new Error('ws client is null'))
+                return
+            }
             const client = new WebSocket(this.url)
 
             client.on(WebSocketStateEnum.OPEN, () => {
@@ -154,7 +157,7 @@ class WebSocketClient {
             })
 
             // eslint-disable-next-line no-unused-vars
-            client.on(WebSocketStateEnum.ERROR, (error) => {
+            client.on(WebSocketStateEnum.ERROR, (/** @type {unknown} */ error) => {
                 reject(error)
             })
 

package/lib/core/webSocketClient/WebSocketClientBrowser.js

@@ -1,6 +1,6 @@
+// @ts-check
 import { isBrowserRuntime } from "../../utils/Runtime.js"
 
-// @ts-nocheck
 const WebSocketState = /** @type {const} */ ({
     OPEN: 'open',
     CLOSE: 'close',
@@ -9,13 +9,12 @@ const WebSocketState = /** @type {const} */ ({
 })
 
 /**
- * @type {WebSocket | null}
+ * @type {typeof WebSocket | null}
  */
 let WsClient = null
 
 if (isBrowserRuntime()) {
-    /** @type {WebSocket} */
-    // @ts-ignore
+    /** @type {typeof WebSocket} */
     WsClient = WebSocket
 }
 
@@ -96,8 +95,8 @@ class WebSocketClientBrowser {
      */
     _connect() {
         return new Promise((resolve, reject) => {
-            if (!WsClient || WsClient === null) {
-                reject(new Error('missing WebSocket client'))
+            if (WsClient === null) {
+                return reject(new Error('missing WebSocket client'))
             }
             this.instance = new WsClient(this.url)
             this.instance.binaryType = 'arraybuffer'

package/lib/sdk/ConfigRuntimeFactory.js

@@ -1,35 +1,31 @@
+// @ts-check
 import { WsConnectionData } from '../utils/connectionData/WsConnectionData.js'
 import { TcpConnectionData } from '../utils/nodejs/connectionData/TcpConnectionData.js'
 import { RuntimeName } from '../utils/RuntimeName.js'
 import { RuntimeNameHandler } from '../utils/RuntimeNameHandler.js'
 import { RuntimeContext } from './RuntimeContext.js'
-import { ConfigSourceResolver } from './tools/browser/ConfigSourceResolver.js'
-import { isNodejsRuntime, isBrowserRuntime, getRequire } from '../utils/Runtime.js'
-import { JsonFileResolver } from './tools/nodejs/JsonFileResolver.js'
+import { isNodejsRuntime, isBrowserRuntime, getRequire, getDirname } from '../utils/Runtime.js'
 import { InMemoryConnectionData } from '../utils/connectionData/InMemoryConnectionData.js'
+import { JsonResolver } from './tools/JsonResolver.js'
+import { UtilsConst } from '../utils/UtilsConst.js'
 
 const requireDynamic = getRequire(import.meta.url)
+
+/**
+ * @typedef {import('../types.d.ts').ConfigSource} ConfigSource
+ * @typedef {import('../types.d.ts').RuntimeName} RuntimeNameType
+ */
 /**
  * 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)
  */
 export class ConfigRuntimeFactory {
-    /** @type {import('../core/transmitter/Transmitter.js') | null} */
-    transmitter = null
-
     /**
-     * @param {object | string} configSource
-     * @param {import('../core/transmitter/Transmitter.js') | null} transmitter
+     * @param {ConfigSource | string} configSource
      */
-    constructor(configSource, transmitter = null) {
+    constructor(configSource) {
         this.configSource = configSource
-        this.transmitter = transmitter
-
-        if (isNodejsRuntime()) {
-            // @ts-ignore
-            this.transmitter?.setConfigSource(configSource)
-        }
     }
 
     /**
@@ -113,93 +109,99 @@ export class ConfigRuntimeFactory {
     }
 
     /**
-     * @param {number} runtime
+     * @param {RuntimeNameType} runtime
      * @param {string} configName
-     * @returns
+     * @returns {RuntimeContext}
      */
     #getRuntimeContext(runtime, configName = 'default') {
+        const jsonResolver = new JsonResolver(this.configSource)
+
+        UtilsConst.setLicenseKey(jsonResolver.getLicenseKey())
+        if (jsonResolver.getWorkingDirectory()) {
+            UtilsConst.setJavonetWorkingDirectory(jsonResolver.getWorkingDirectory())
+        }
+
         if (isBrowserRuntime()) {
-            const jfr = new ConfigSourceResolver(this.configSource)
-            const connType = jfr.getChannelType(RuntimeNameHandler.getName(runtime), configName)
-            let connData = null
+            const channelType = jsonResolver.getChannelType(RuntimeNameHandler.getName(runtime), configName)
+            let connectionData = null
 
-            if (connType === 'webSocket') {
-                connData = new WsConnectionData(
-                    jfr.getChannelHost(RuntimeNameHandler.getName(runtime), configName)
+            if (channelType === 'webSocket') {
+                connectionData = new WsConnectionData(
+                    jsonResolver.getChannelHost(RuntimeNameHandler.getName(runtime), configName)
                 )
             } else {
-                throw new Error('Unsupported connection type: ' + connType)
+                throw new Error('Unsupported connection type: ' + channelType)
             }
 
-            const rtmCtx = RuntimeContext.getInstance(runtime, connData)
-            this.#loadModules(runtime, configName, jfr, rtmCtx)
+            const rtmCtx = RuntimeContext.getInstance(runtime, connectionData)
+            this.#loadModules(runtime, configName, jsonResolver, rtmCtx)
             return rtmCtx
         }
 
         if (isNodejsRuntime()) {
-            let jfr = new JsonFileResolver(this.configSource)
-
             try {
-                const licenseKey = jfr.getLicenseKey()
-                this.transmitter?.activate(licenseKey)
+                const channelType = jsonResolver.getChannelType(
+                    RuntimeNameHandler.getName(runtime),
+                    configName
+                )
+                const licenseKey = jsonResolver.getLicenseKey()
+
+                let connectionData = null
+                if (channelType === 'inMemory') {
+                    connectionData = new InMemoryConnectionData()
+                } else if (channelType === 'tcp') {
+                    connectionData = new TcpConnectionData(
+                        jsonResolver.getChannelHost(RuntimeNameHandler.getName(runtime), configName),
+                        /** @type {number} */ (jsonResolver.getChannelPort(RuntimeNameHandler.getName(runtime), configName))
+                    )
+                } else if (channelType === 'webSocket') {
+                    connectionData = new WsConnectionData(
+                        jsonResolver.getChannelHost(RuntimeNameHandler.getName(runtime), configName)
+                    )
+                } else {
+                    throw new Error('Unsupported connection type: ' + channelType)
+                }
+
+                const rtmCtx = RuntimeContext.getInstance(runtime, connectionData)
+                this.#loadModules(runtime, configName, jsonResolver, rtmCtx)
+                return rtmCtx
             } catch (error) {
                 throw error
             }
-
-            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
         }
+
+        throw new Error('Unsupported runtime environment')
     }
 
-    // @ts-ignore
-    #loadModules(runtime, configName, jfr, rtmCtx) {
+    /**
+     * @param {number} runtime
+     * @param {string} configName
+     * @param {JsonResolver} jsonResolver
+     * @param {RuntimeContext} rtmCtx
+     */
+    #loadModules(runtime, configName, jsonResolver, rtmCtx) {
         try {
-            const modules = jfr
+            const modules = jsonResolver
                 .getModules(RuntimeNameHandler.getName(runtime), configName)
                 .split(',')
-                // @ts-ignore
                 .filter((module) => module.trim() !== '')
 
             if (isNodejsRuntime()) {
-                if (typeof this.configSource !== 'string') {
-                    throw new Error('configSource is not a string')
-                }
-
-                const path = requireDynamic('path')
-                const configDirectoryAbsolutePath = path?.dirname(this.configSource)
-                // @ts-ignore
+                const path = /** @type {import('path').PlatformPath} */ (
+                    /** @type {unknown} */ (requireDynamic('path'))
+                )
+                // TODO: make sure that relative path works
+                const configDirectoryAbsolutePath = process.cwd()
                 modules.forEach((module) => {
-                    if (path?.isAbsolute(module)) {
+                    if (path.isAbsolute(module)) {
                         rtmCtx.loadLibrary(module)
                     } else {
-                        rtmCtx.loadLibrary(path?.join(configDirectoryAbsolutePath, module))
+                        rtmCtx.loadLibrary(path.join(configDirectoryAbsolutePath, module))
                     }
                 })
             }
-            // eslint-disable-next-line no-unused-vars
         } catch (error) {
             throw error
-            // most likely browser will never support this
         }
     }
 }