javonet-nodejs-sdk 2.5.17 → 2.5.18

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
         }
     }
 }

package/lib/sdk/InvocationContext.js

@@ -1,3 +1,4 @@
+//@ts-check
 import { delegatesCacheInstance } from '../core/delegatesCache/DelegatesCache.js'
 import { Interpreter } from '../core/interpreter/Interpreter.js'
 import { Command } from '../utils/Command.js'
@@ -5,6 +6,12 @@ import { CommandType } from '../utils/CommandType.js'
 import { ConnectionType } from '../utils/ConnectionType.js'
 import { ExceptionThrower } from '../utils/exception/ExceptionThrower.js'
 import { RuntimeName } from '../utils/RuntimeName.js'
+import { TypesHandler } from '../utils/TypesHandler.js'
+
+/**
+ * @typedef {import('../types.d.ts').RuntimeName} RuntimeNameType
+ * @typedef {import('../utils/connectionData/IConnectionData.js').IConnectionData} IConnectionData
+ */
 
 /**
  * InvocationContext is a class that represents a context for invoking commands.
@@ -14,15 +21,28 @@ import { RuntimeName } from '../utils/RuntimeName.js'
  * @class
  */
 class InvocationContext {
+    /** @type {RuntimeNameType} */
     #runtimeName
+    /** @type {IConnectionData} */
     #connectionData
-    #currentCommand
-    #responseCommand
-    #interpreter
-    // eslint-disable-next-line no-unused-private-class-members
-    #isExecuted
-    #resultValue
+    /** @type {Command | null} */
+    #currentCommand = null
+    /** @type {Command | null} */
+    #responseCommand = null
+    /** @type {boolean} */
+    #isExecuted = false
+    /** @type {any | null} */
+    #resultValue = null
+    /** @type {Interpreter | null} */
+    #interpreter = null
 
+    /**
+     *
+     * @param {RuntimeNameType} runtimeName
+     * @param {IConnectionData} connectionData
+     * @param {Command} command
+     * @param {boolean} isExecuted
+     */
     constructor(runtimeName, connectionData, command, isExecuted = false) {
         this.#runtimeName = runtimeName
         this.#connectionData = connectionData
@@ -33,8 +53,13 @@ class InvocationContext {
         this.#resultValue = null
     }
 
+    /**
+     * @param {Command} localCommand
+     * @returns {InvocationContext}
+     */
     #createInstanceContext(localCommand) {
         if (this.#connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            // @ts-expect-error
             return new InvocationWsContext(
                 this.#runtimeName,
                 this.#connectionData,
@@ -48,6 +73,9 @@ class InvocationContext {
         )
     }
 
+    /**
+     * @returns {Command|null}
+     */
     get_current_command() {
         return this.#currentCommand
     }
@@ -63,12 +91,12 @@ class InvocationContext {
     //    }
     //}
 
-    [Symbol.iterator] = function () {
-        if (this.#currentCommand.commandType !== CommandType.Reference) {
+    [Symbol.iterator] = () => {
+        if (this.#currentCommand?.commandType !== CommandType.Reference) {
             throw new Error('Object is not iterable')
         }
         let position = -1
-        let arraySize = this.getSize().execute().getValue()
+        const arraySize = Number(this.getSize().execute().getValue())
 
         return {
             next: () => ({
@@ -90,21 +118,25 @@ class InvocationContext {
      * @method
      */
     execute() {
+        if (this.#currentCommand === null) {
+            throw new Error('currentCommand is undefined in Invocation Context execute method')
+        }
+
         this.#interpreter = new Interpreter()
+        //@ts-expect-error
         this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.#connectionData)
-        if (this.#responseCommand === undefined) {
+
+        if (!this.#responseCommand) {
             throw new Error('responseCommand is undefined in Invocation Context execute method')
         }
-        if (this.#responseCommand.commandType === CommandType.Exception) {
+        if (this.#responseCommand?.commandType === CommandType.Exception) {
             throw ExceptionThrower.throwException(this.#responseCommand)
         }
-
-        if (this.#responseCommand.commandType === CommandType.CreateClassInstance) {
+        if (this.#responseCommand?.commandType === CommandType.CreateClassInstance) {
             this.#currentCommand = this.#responseCommand
             this.#isExecuted = true
             return this
         }
-
         return new InvocationContext(this.#runtimeName, this.#connectionData, this.#responseCommand, true)
     }
 
@@ -347,7 +379,7 @@ class InvocationContext {
      * Creates a null object of a specific type on the target runtime.
      * @param {string} methodName - The name of the method to invoke.
      * @param {...any} args - Method arguments.
-     * @returns {InvocationContext} An InvocationContext instance with the command to create a null object.
+     * @returns {InvocationContext|InvocationWsContext} An InvocationContext instance with the command to create a null object.
      * TODO: connect documentation page url
      * @see [Javonet Guides](https://www.javonet.com/guides/)
      * @method
@@ -374,6 +406,10 @@ class InvocationContext {
             this.#buildCommand(localCommand)
         )
         localInvCtx.execute()
+
+        if (localInvCtx.#responseCommand === null) {
+            throw new Error('responseCommand is undefined in Invocation Context execute method')
+        }
         return localInvCtx.#responseCommand.payload
     }
 
@@ -385,19 +421,30 @@ class InvocationContext {
      * @method
      */
 
+    /**
+     * @returns {unknown}
+     */
     getValue() {
-        this.#resultValue = this.#currentCommand.payload[0]
+        this.#resultValue = this.#currentCommand?.payload[0]
         return this.#resultValue
     }
 
-    #buildCommand = function (command) {
+    /**
+     * @param {Command} command
+     * @returns {Command}
+     */
+    #buildCommand(command) {
         for (let i = 0; i < command.payload.length; i++) {
             command.payload[i] = this.#encapsulatePayloadItem(command.payload[i])
         }
         return command.prependArgToPayload(this.#currentCommand)
     }
 
-    #encapsulatePayloadItem = function (payloadItem) {
+    /**
+     * @param {unknown} payloadItem
+     * @returns {Command|null}
+     */
+    #encapsulatePayloadItem(payloadItem) {
         // eslint-disable-next-line valid-typeof
         if (payloadItem instanceof Command) {
             for (let i = 0; i < payloadItem.payload.length; i++) {
@@ -409,7 +456,7 @@ class InvocationContext {
             return payloadItem.get_current_command()
         } else if (payloadItem instanceof Array) {
             const copiedArray = payloadItem.map((item) => this.#encapsulatePayloadItem(item))
-            return new Command(this.runtimeName, CommandType.Array, copiedArray)
+            return new Command(this.#runtimeName, CommandType.Array, copiedArray)
         } else if (typeof payloadItem === 'function') {
             let newArray = new Array(payloadItem.length + 1)
             for (let i = 0; i < newArray.length; i++) {
@@ -419,23 +466,41 @@ class InvocationContext {
                 ...newArray
             )
             return new Command(this.#runtimeName, CommandType.PassDelegate, args)
+        } else if (TypesHandler.isPrimitiveOrNullOrUndefined(payloadItem)) {
+            return new Command(this.#runtimeName, CommandType.Value, [payloadItem])
         } else {
-            return new Command(this.runtimeName, CommandType.Value, [payloadItem])
+            throw Error(
+                'Unsupported payload item type: ' +
+                    (payloadItem?.constructor?.name || typeof payloadItem) +
+                    ' for payload item: ' +
+                    payloadItem
+            )
         }
     }
 }
 
 class InvocationWsContext extends InvocationContext {
+    /** @type {RuntimeNameType} */
     #runtimeName
+    /** @type {IConnectionData} */
     #connectionData
+    /** @type {Command | null} */
     #currentCommand
+    /** @type {Command | null} */
     #responseCommand
+    /** @type {Interpreter | null} */
     #interpreter
-    // eslint-disable-next-line no-unused-private-class-members
+    /** @type {boolean} */
     #isExecuted
-    // eslint-disable-next-line no-unused-private-class-members
+    /** @type {any | null} */
     #resultValue
 
+    /**
+     * @param {RuntimeNameType} runtimeName
+     * @param {IConnectionData} connectionData
+     * @param {Command} command
+     * @param {boolean} isExecuted
+     */
     constructor(runtimeName, connectionData, command, isExecuted = false) {
         super(runtimeName, connectionData, command, isExecuted)
 
@@ -455,11 +520,17 @@ class InvocationWsContext extends 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<InvocationWsContext>} the InvocationContext after executing the command.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
+     * @async
      * @method
      */
+    // @ts-expect-error
     async execute() {
+        if (this.#currentCommand === null) {
+            throw new Error('currentCommand is undefined in Invocation Context execute method')
+        }
+
         this.#interpreter = new Interpreter()
         this.#responseCommand = await this.#interpreter.executeAsync(
             this.#currentCommand,
@@ -469,17 +540,14 @@ class InvocationWsContext extends InvocationContext {
         if (this.#responseCommand === undefined) {
             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
         }
-
         return new InvocationWsContext(this.#runtimeName, this.#connectionData, this.#responseCommand, true)
     }
 }