javonet-nodejs-sdk 2.5.16 → 2.5.18

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

package/lib/sdk/Javonet.js

@@ -1,3 +1,4 @@
+//@ts-check
 import { ConfigRuntimeFactory } from './ConfigRuntimeFactory.js'
 import { RuntimeFactory } from './RuntimeFactory.js'
 import { InMemoryConnectionData } from '../utils/connectionData/InMemoryConnectionData.js'
@@ -7,10 +8,14 @@ import { CommandDeserializer } from '../core/protocol/CommandDeserializer.js'
 import { RuntimeLogger } from '../utils/RuntimeLogger.js'
 import { TcpConnectionData } from '../utils/nodejs/connectionData/TcpConnectionData.js'
 import { WsConnectionData } from '../utils/connectionData/WsConnectionData.js'
+import { ActivationHelper } from './tools/ActivationHelper.js'
+import { UtilsConst } from '../utils/UtilsConst.js'
+
+/** @typedef {import('../types.d.ts').ConfigSource} ConfigSource */
 
 const requireDynamic = getRequire(import.meta.url)
 
-/** @type {import('../core/transmitter/Transmitter') | null} */
+/** @type {typeof import('../core/transmitter/Transmitter.js').Transmitter | null} */
 let _Transmitter = null
 
 if (isNodejsRuntime()) {
@@ -64,28 +69,28 @@ class Javonet {
     /**
      * Initializes Javonet with a custom configuration file taken from external source.
      * Currentyl supported: Configuration file in JSON format
-     * @param config - Path to a configuration file.
+     * @param {string|ConfigSource} config - Path to a configuration file.
      * @returns {ConfigRuntimeFactory} A ConfigRuntimeFactory instance with configuration data.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/configure-channel)
      */
     static withConfig(config) {
-        return new ConfigRuntimeFactory(config, _Transmitter)
+        return new ConfigRuntimeFactory(config)
     }
 
     /**
      * Activates Javonet with the provided license key.
      * @param {string} licenseKey - The license key to activate Javonet.
-     * @returns {number} The activation status code.
+     * @returns {void} The activation status code.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/getting-started/activating-javonet)
      */
     static activate(licenseKey) {
-        if (isNodejsRuntime()) {
-            return _Transmitter?.activate(licenseKey)
-        } else {
-            throw new Error('Javonet.activate is allowed only to run in nodejs runtime')
-        }
+        UtilsConst.setLicenseKey(licenseKey)
     }
 
+    /**
+     * Gets the runtime information.
+     * @returns {string} The runtime information.
+     */
     static getRuntimeInfo() {
         if (isNodejsRuntime()) {
             return RuntimeLogger.getRuntimeInfo()
@@ -96,43 +101,20 @@ class Javonet {
 
     /**
      * Sets the configuration source for the Javonet SDK.
-     *
      * @param {string} configSource - The configuration source.
+     * @returns {void}
      */
     static setConfigSource(configSource) {
-        if (isNodejsRuntime()) {
-            return _Transmitter?.setConfigSource(configSource)
-        } else {
-            throw new Error('Javonet.setConfigSource is allowed only to run in nodejs runtime')
-        }
+        UtilsConst.setConfigSource(configSource)
     }
 
     /**
      * Sets the working directory for the Javonet SDK.
-     *
      * @param {string} path - The working directory.
+     * @returns {void}
      */
     static setJavonetWorkingDirectory(path) {
-        try {
-            if (isNodejsRuntime()) {
-                const { mkdirSync } = requireDynamic('fs')
-
-                path = path.replace(/\\/g, '/')
-                if (!path.endsWith('/')) {
-                    path += '/'
-                }
-
-                mkdirSync(path, { recursive: true, mode: 0o700 })
-                _Transmitter?.setJavonetWorkingDirectory(path)
-            } else {
-                throw new Error('Javonet.setJavonetWorkingDirectory is allowed only to run in nodejs runtime')
-            }
-        } catch (error) {
-            if (error.code === 'MODULE_NOT_FOUND') {
-                throw new Error('fs module not found. Please install it using npm install fs')
-            }
-            throw error
-        }
+        UtilsConst.setJavonetWorkingDirectory(path)
     }
 }
 

package/lib/sdk/RuntimeContext.js

@@ -1,4 +1,4 @@
-/* eslint-disable valid-typeof */
+// @ts-check
 import { Command } from '../utils/Command.js'
 import { CommandType } from '../utils/CommandType.js'
 import { InvocationContext, InvocationWsContext } from './InvocationContext.js'
@@ -7,6 +7,20 @@ import { ExceptionThrower } from '../utils/exception/ExceptionThrower.js'
 import { RuntimeName } from '../utils/RuntimeName.js'
 import { Interpreter } from '../core/interpreter/Interpreter.js'
 import { delegatesCacheInstance } from '../core/delegatesCache/DelegatesCache.js'
+import { TypesHandler } from '../utils/TypesHandler.js'
+import { UtilsConst } from '../utils/UtilsConst.js'
+import { getRequire } from '../utils/Runtime.js'
+
+/**
+ * @typedef {import('../types.d.ts').RuntimeName} RuntimeNameType
+ * @typedef {import('../utils/connectionData/IConnectionData.js').IConnectionData} IConnectionData
+ * @typedef {typeof import('../core/transmitter/Transmitter.js').Transmitter} Transmitter
+ */
+
+/** @type {typeof import('../core/transmitter/Transmitter.js').Transmitter | null} */
+let _Transmitter = null
+
+const requireDynamic = getRequire(import.meta.url)
 
 /**
  * Represents a single context which allows interaction with a selected technology.
@@ -20,54 +34,93 @@ import { delegatesCacheInstance } from '../core/delegatesCache/DelegatesCache.js
  * @class
  */
 class RuntimeContext {
+    /** @type {Map<string, RuntimeContext>} */
     static memoryRuntimeContexts = new Map()
+    /** @type {Map<string, RuntimeContext>} */
     static networkRuntimeContexts = new Map()
+    /** @type {Map<string, RuntimeContext>} */
     static webSocketRuntimeContexts = new Map()
-    #currentCommand
-    #responseCommand
-    #interpreter
 
+    /** @type {Command | null} */
+    #currentCommand = null
+    /** @type {Command | null} */
+    #responseCommand = null
+    /** @type {Interpreter | null} */
+    #interpreter = null
+
+    /**
+     * @param {RuntimeNameType} runtimeName
+     * @param {IConnectionData} connectionData
+     */
     constructor(runtimeName, connectionData) {
+        this._isExecuted = false
         this.runtimeName = runtimeName
         this.connectionData = connectionData
-        this.#currentCommand = null
-        this.#responseCommand = null
         this.#interpreter = new Interpreter()
+
+        if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            return
+        }
+        if (
+            this.runtimeName === RuntimeName.Nodejs &&
+            this.connectionData.connectionType === ConnectionType.IN_MEMORY
+        ) {
+            return
+        }
+
+        _Transmitter?.setJavonetWorkingDirectory(UtilsConst.getJavonetWorkingDirectory())
+        if (UtilsConst.getConfigSource() !== '') {
+            _Transmitter?.setConfigSource(UtilsConst.getConfigSource())
+        }
+        _Transmitter?.activate(UtilsConst.getLicenseKey())
     }
 
+    /**
+     * @param {RuntimeNameType} runtimeName
+     * @param {IConnectionData} connectionData
+     * @returns {RuntimeContext}
+     */
     static getInstance(runtimeName, connectionData) {
+        if (!_Transmitter) {
+            const { Transmitter } = requireDynamic('../core/transmitter/Transmitter.js')
+            _Transmitter = Transmitter
+        }
         switch (connectionData.connectionType) {
             case ConnectionType.IN_MEMORY:
-                if (runtimeName in RuntimeContext.memoryRuntimeContexts) {
-                    let runtimeCtx = RuntimeContext.memoryRuntimeContexts[runtimeName]
-                    runtimeCtx.currentCommand = null
+                const key = String(runtimeName)
+                if (RuntimeContext.memoryRuntimeContexts.has(key)) {
+                    const runtimeCtx = RuntimeContext.memoryRuntimeContexts.get(key)
+                    if (!runtimeCtx) throw new Error('Runtime context not found')
+                    runtimeCtx.#currentCommand = null
                     return runtimeCtx
                 } else {
-                    let runtimeCtx = new RuntimeContext(runtimeName, connectionData)
-                    RuntimeContext.memoryRuntimeContexts[runtimeName] = runtimeCtx
+                    const runtimeCtx = new RuntimeContext(runtimeName, connectionData)
+                    RuntimeContext.memoryRuntimeContexts.set(key, runtimeCtx)
                     return runtimeCtx
                 }
             case ConnectionType.TCP: {
-                let key1 = runtimeName + JSON.stringify(connectionData)
-                if (key1 in RuntimeContext.networkRuntimeContexts) {
-                    let runtimeCtx = RuntimeContext.networkRuntimeContexts[key1]
-                    runtimeCtx.currentCommand = null
+                const key1 = String(runtimeName) + JSON.stringify(connectionData)
+                if (RuntimeContext.networkRuntimeContexts.has(key1)) {
+                    const runtimeCtx = RuntimeContext.networkRuntimeContexts.get(key1)
+                    if (!runtimeCtx) throw new Error('Runtime context not found')
+                    runtimeCtx.#currentCommand = null
                     return runtimeCtx
                 } else {
-                    let runtimeCtx = new RuntimeContext(runtimeName, connectionData)
-                    RuntimeContext.networkRuntimeContexts[key1] = runtimeCtx
+                    const runtimeCtx = new RuntimeContext(runtimeName, connectionData)
+                    RuntimeContext.networkRuntimeContexts.set(key1, runtimeCtx)
                     return runtimeCtx
                 }
             }
             case ConnectionType.WEB_SOCKET: {
-                let key2 = runtimeName + JSON.stringify(connectionData)
-                if (key2 in RuntimeContext.webSocketRuntimeContexts) {
-                    let runtimeCtx = RuntimeContext.webSocketRuntimeContexts[key2]
-                    runtimeCtx.currentCommand = null
+                const key2 = String(runtimeName) + JSON.stringify(connectionData)
+                if (RuntimeContext.webSocketRuntimeContexts.has(key2)) {
+                    const runtimeCtx = RuntimeContext.webSocketRuntimeContexts.get(key2)
+                    if (!runtimeCtx) throw new Error('Runtime context not found')
+                    runtimeCtx.#currentCommand = null
                     return runtimeCtx
                 } else {
-                    let runtimeCtx = new RuntimeContext(runtimeName, connectionData)
-                    RuntimeContext.webSocketRuntimeContexts[key2] = runtimeCtx
+                    const runtimeCtx = new RuntimeContext(runtimeName, connectionData)
+                    RuntimeContext.webSocketRuntimeContexts.set(key2, runtimeCtx)
                     return runtimeCtx
                 }
             }
@@ -86,12 +139,13 @@ class RuntimeContext {
      * @method
      */
     execute() {
-        this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.connectionData)
+        // @ts-expect-error
+        this.#responseCommand = this.#interpreter?.execute(this.#currentCommand, this.connectionData)
         this.#currentCommand = null
         if (this.#responseCommand === undefined) {
             throw new Error('responseCommand is undefined in Runtime Context execute method')
         }
-        if (this.#responseCommand.commandType === CommandType.Exception) {
+        if (this.#responseCommand?.commandType === CommandType.Exception) {
             throw ExceptionThrower.throwException(this.#responseCommand)
         }
     }
@@ -124,6 +178,7 @@ class RuntimeContext {
         let localCommand = new Command(this.runtimeName, CommandType.GetType, [typeName, ...args])
         this.#currentCommand = null
         if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            // @ts-expect-error
             return new InvocationWsContext(
                 this.runtimeName,
                 this.connectionData,
@@ -146,6 +201,7 @@ class RuntimeContext {
         let localCommand = new Command(this.runtimeName, CommandType.Cast, args)
         this.#currentCommand = null
         if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            // @ts-expect-error
             return new InvocationWsContext(
                 this.runtimeName,
                 this.connectionData,
@@ -168,6 +224,7 @@ class RuntimeContext {
         let localCommand = new Command(this.runtimeName, CommandType.GetEnumItem, args)
         this.#currentCommand = null
         if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            // @ts-expect-error
             return new InvocationWsContext(
                 this.runtimeName,
                 this.connectionData,
@@ -190,6 +247,7 @@ class RuntimeContext {
         let localCommand = new Command(this.runtimeName, CommandType.AsRef, args)
         this.#currentCommand = null
         if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            // @ts-expect-error
             return new InvocationWsContext(
                 this.runtimeName,
                 this.connectionData,
@@ -212,6 +270,7 @@ class RuntimeContext {
         let localCommand = new Command(this.runtimeName, CommandType.AsOut, args)
         this.#currentCommand = null
         if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            // @ts-expect-error
             return new InvocationWsContext(
                 this.runtimeName,
                 this.connectionData,
@@ -238,6 +297,7 @@ class RuntimeContext {
         ])
         this.#currentCommand = null
         if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            // @ts-expect-error
             return new InvocationWsContext(
                 this.runtimeName,
                 this.connectionData,
@@ -247,22 +307,35 @@ class RuntimeContext {
         return new InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand))
     }
 
-    #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}
+     */
+    #encapsulatePayloadItem(payloadItem) {
         if (payloadItem instanceof Command) {
             for (let i = 0; i < payloadItem.payload.length; i++) {
                 payloadItem.payload[i] = this.#encapsulatePayloadItem(payloadItem.payload[i])
             }
             return payloadItem
         } else if (payloadItem instanceof InvocationContext) {
-            return payloadItem.get_current_command()
+            const command = payloadItem?.get_current_command()
+            if (!command) {
+                throw new Error('Command not found')
+            }
+            return command
         } else if (payloadItem instanceof Array) {
+            /** @type {Command[]} */
             const copiedArray = payloadItem.map((item) => this.#encapsulatePayloadItem(item))
             return new Command(this.runtimeName, CommandType.Array, copiedArray)
         } else if (typeof payloadItem === 'function') {
@@ -274,8 +347,15 @@ class RuntimeContext {
                 ...newArray
             )
             return new Command(this.runtimeName, CommandType.PassDelegate, args)
-        } else {
+        } else if (TypesHandler.isPrimitiveOrNullOrUndefined(payloadItem)) {
             return new Command(this.runtimeName, CommandType.Value, [payloadItem])
+        } else {
+            throw Error(
+                'Unsupported payload item type: ' +
+                    (payloadItem?.constructor?.name || typeof payloadItem) +
+                    ' for payload item: ' +
+                    payloadItem
+            )
         }
     }
 

package/lib/sdk/RuntimeFactory.js

@@ -1,12 +1,19 @@
+//@ts-check
 import { RuntimeName } from '../utils/RuntimeName.js'
 import { RuntimeContext } from './RuntimeContext.js'
 
+/**
+ * @typedef {import('../utils/connectionData/IConnectionData.js').IConnectionData} IConnectionData
+ */
 /**
  * The RuntimeFactory 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 RuntimeFactory {
+    /**
+     * @param {IConnectionData} connectionData 
+     */
     constructor(connectionData) {
         this.connectionData = connectionData
     }