javonet-nodejs-sdk 2.5.9 → 2.5.10

package/lib/core/handler/ConvertTypeHandler.js

@@ -0,0 +1,38 @@
+const { TypesConverter } = require('../../utils/TypesConverter')
+const AbstractHandler = require('./AbstractHandler')
+
+/**
+ * ConvertTypeHandler class handles the conversion of JType to Type.
+ */
+class ConvertTypeHandler extends AbstractHandler {
+    constructor() {
+        super()
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        this.requiredParametersCount = 1
+    }
+
+    /**
+     * Processes the given command to convert JType to Type.
+     * @param {Object} command - The command to process.
+     * @returns {any} The converted type.
+     */
+    process(command) {
+        this.validateCommand(command)
+        return TypesConverter.convertJTypeToType(command.payload[0])
+    }
+
+    /**
+     * Validates the command to ensure it has enough parameters.
+     * @param {Object} command - The command to validate.
+     */
+    validateCommand(command) {
+        if (command.payload.length < this.requiredParametersCount) {
+            throw new Error('ConvertTypeHandler parameters mismatch')
+        }
+    }
+}
+
+module.exports = ConvertTypeHandler

package/lib/core/handler/GetInstanceMethodAsDelegateHandler.js

@@ -0,0 +1,73 @@
+const AbstractHandler = require('./AbstractHandler')
+
+/**
+ * Handles retrieving an instance method as a delegate.
+ */
+class GetInstanceMethodAsDelegateHandler extends AbstractHandler {
+    constructor() {
+        super()
+        /** @type {Function|null} */
+        this.method = null
+        /** @type {number} */
+        this.requiredParametersCount = 2
+        /** @type {Array<*>} */
+        this.args = []
+        /** @type {Object|null} */
+        this.instance = null
+    }
+
+    /**
+     * Processes a command to retrieve an instance method as a delegate.
+     * @param {Object} command - The command containing payload data.
+     * @param {Array<*>} command.payload - The payload containing instance, method name, and arguments.
+     * @returns {Function} The delegate for the instance method.
+     * @throws {Error} If the parameters mismatch or the method cannot be found.
+     */
+    process(command) {
+        if (command.payload.length < this.requiredParametersCount) {
+            throw new Error(`${this.constructor.name} parameters mismatch`)
+        }
+
+        this.instance = command.payload[0]
+        const methodName = command.payload[1]
+        this.args = command.payload.length > 2 ? command.payload.slice(2) : []
+
+        // Find the method on the instance
+        this.method = this.getMethod(this.instance, methodName)
+        if (!this.method) {
+            throw this.createMethodNotFoundError(this.instance, methodName)
+        }
+
+        // Create a delegate from the method
+        const methodDelegate = this.method.bind(this.instance)
+        return methodDelegate
+    }
+
+    /**
+     * Retrieves the method from the type.
+     * @param {Object} type - The class or constructor to search for the method.
+     * @param {string} methodName - The name of the method.
+     * @returns {Function|null} The found method or null if not found.
+     */
+    getMethod(type, methodName) {
+        const method = type[methodName]
+        return typeof method === 'function' ? method : null
+    }
+
+    /**
+     * Creates an error message when the method is not found.
+     * @param {Object} type - The class or constructor.
+     * @param {string} methodName - The method name.
+     * @returns {Error} The error with detailed message.
+     */
+    createMethodNotFoundError(type, methodName) {
+        const methods = Object.getOwnPropertyNames(type.prototype).filter(
+            (key) => typeof type.prototype[key] === 'function'
+        )
+        const availableMethods = methods.map((name) => `${name}()`)
+        const message = `Method ${methodName} not found in class ${type.name}. Available instance public methods:\n${availableMethods.join('\n')}`
+        return new Error(message)
+    }
+}
+
+module.exports = new GetInstanceMethodAsDelegateHandler()

package/lib/core/handler/GetStaticMethodAsDelegateHandler.js

@@ -0,0 +1,74 @@
+// eslint-disable-next-line no-unused-vars
+const { Command } = require('@javonet/core')
+const AbstractHandler = require('./AbstractHandler')
+
+/**
+ * Handles retrieving a static method as a delegate.
+ */
+class GetStaticMethodAsDelegateHandler extends AbstractHandler {
+    /** @type {Array<*>} */
+    args = []
+
+    constructor() {
+        super()
+        /** @type {Function|null} */
+        this.method = null
+        /** @type {number} */
+        this.requiredParametersCount = 2
+    }
+
+    /**
+     * Processes a command to retrieve a static method as a delegate.
+     * @param {Command} command - The command containing payload data.
+     * @param {Array<*>} command.payload - The payload containing type, method name, and arguments.
+     * @returns {Function} The delegate for the static method.
+     * @throws {Error} If the parameters mismatch or the method cannot be found.
+     */
+    process(command) {
+        if (command.payload.length < this.requiredParametersCount) {
+            throw new Error(`${this.constructor.name} parameters mismatch`)
+        }
+
+        const type = command.payload[0]
+        const methodName = command.payload[1]
+        this.args = command.payload.length > 2 ? command.payload.slice(2) : []
+
+        // Find the method on the type
+        this.method = this.getMethod(type, methodName)
+        if (!this.method) {
+            throw this.createMethodNotFoundError(type, methodName)
+        }
+
+        // Create a delegate from the method
+        const methodDelegate = this.method.bind(this)
+        return methodDelegate
+    }
+
+    /**
+     * Retrieves the method from the type.
+     * @param {Object} type - The class or constructor to search for the method.
+     * @param {string} methodName - The name of the method.
+     * @param {Array<Function>} argsType - The argument types.
+     * @param {Object} modifier - Parameter modifier (not used in JS implementation).
+     * @returns {Function|null} The found method or null if not found.
+     */
+    getMethod(type, methodName) {
+        const method = type[methodName]
+        return typeof method === 'function' ? method : null
+    }
+
+    /**
+     * Creates an error message when the method is not found.
+     * @param {Object} type - The class or constructor.
+     * @param {string} methodName - The method name.
+     * @returns {Error} The error with detailed message.
+     */
+    createMethodNotFoundError(type, methodName) {
+        const methods = Object.keys(type).filter((key) => typeof type[key] === 'function')
+        const availableMethods = methods.map((name) => `${name}()`)
+        const message = `Method ${methodName} not found in class ${type.name}. Available public static methods:\n${availableMethods.join('\n')}`
+        return new Error(message)
+    }
+}
+
+module.exports = new GetStaticMethodAsDelegateHandler()

package/lib/core/handler/Handler.js

@@ -23,6 +23,11 @@ const EnableTypeHandler = require('./EnableTypeHandler')
 const { CommandType, Command, ExceptionSerializer } = require('@javonet/core')
 const ReferencesCache = require('../referenceCache/ReferencesCache')
 const InvokeStandaloneMethodHandler = require('./InvokeStandaloneMethodHandler')
+const GetStaticMethodAsDelegateHandler = require('./GetStaticMethodAsDelegateHandler')
+const GetInstanceMethodAsDelegateHandler = require('./GetInstanceMethodAsDelegateHandler')
+const PassDelegateHandler = require('./PassDelegateHandler')
+const InvokeDelegateHandler = require('./InvokeDelegateHandler')
+const { ConvertTypeHandler } = require('../../utils/TypesConverter')
 
 function isResponseSimpleType(response) {
     let type = typeof response
@@ -56,6 +61,11 @@ const handlers = {
     [CommandType.Array]: ArrayHandler,
     [CommandType.EnableNamespace]: EnableNamespaceHandler,
     [CommandType.EnableType]: EnableTypeHandler,
+    [CommandType.GetStaticMethodAsDelegate]: GetStaticMethodAsDelegateHandler,
+    [CommandType.GetInstanceMethodAsDelegate]: GetInstanceMethodAsDelegateHandler,
+    [CommandType.PassDelegate]: PassDelegateHandler,
+    [CommandType.InvokeDelegate]: InvokeDelegateHandler,
+    [CommandType.ConvertType]: ConvertTypeHandler,
 }
 
 Object.keys(handlers).forEach((commandTypeHandler) => {

package/lib/core/handler/InvokeDelegateHandler.js

@@ -0,0 +1,36 @@
+const { DelegatesCache } = require('@javonet/core')
+const AbstractHandler = require('./AbstractHandler')
+
+/**
+ * Handles invoking a delegate by GUID.
+ */
+class InvokeDelegateHandler extends AbstractHandler {
+    constructor() {
+        super()
+        /** @type {number} */
+        this.requiredParametersCount = 1
+    }
+
+    /**
+     * Processes a command to invoke a delegate.
+     * @param {Command} command - The command containing payload data.
+     * @returns {*} The result of the delegate invocation.
+     * @throws {Error} If the parameters mismatch or the delegate cannot be found.
+     */
+    process(command) {
+        const payload = command.payload
+        if (payload.length < this.requiredParametersCount) {
+            throw new Error(`${this.constructor.name} parameters mismatch`)
+        }
+
+        const guid = payload[0]
+        const delegate = DelegatesCache.getDelegate(guid)
+        if (!delegate) {
+            throw new Error('Delegate not found in cache')
+        }
+
+        return delegate
+    }
+}
+
+module.exports = new InvokeDelegateHandler()

package/lib/core/handler/PassDelegateHandler.js

@@ -0,0 +1,157 @@
+// eslint-disable-next-line no-unused-vars
+const { Interpreter, Command, CommandType, InMemoryConnectionData, DelegatesCache } = require('@javonet/core')
+const AbstractHandler = require('./AbstractHandler')
+
+/**
+ * PassDelegateHandler class responsible for processing a command to create a delegate.
+ */
+class PassDelegateHandler extends AbstractHandler {
+    constructor() {
+        super()
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        this.requiredParametersCount = 1
+        this.interpreter = new Interpreter()
+    }
+
+    /**
+     * Processes the given command to create and compile a delegate.
+     * @param {Command} command - The command to process.
+     * @returns {Function} The compiled delegate function.
+     */
+    process(command) {
+        this.validateCommand(command)
+
+        const delegateGuid = command.payload[0]
+        const delegate = DelegatesCache.getDelegate(delegateGuid)
+
+        return delegate
+    }
+
+    /**
+     * Validates the command to ensure it has enough parameters.
+     * @param {Command} command - The command to validate.
+     */
+    validateCommand(command) {
+        if (command.payload.length < this.requiredParametersCount) {
+            throw new Error('PassDelegateHandler parameters mismatch')
+        }
+    }
+
+    /**
+     * Retrieves the arguments from the command payload.
+     * @param {Command} command - The command containing the payload.
+     * @returns {Array} The extracted arguments.
+     */
+    getArguments(command) {
+        return command.payload.length > 2 ? command.payload.slice(2) : []
+    }
+
+    /**
+     * Extracts argument types from the arguments array.
+     * @param {Array} args - The arguments array.
+     * @returns {Array} The argument types.
+     */
+    getArgumentTypes(args) {
+        return args.slice(0, -1).map((arg) => arg.constructor)
+    }
+
+    /**
+     * Retrieves the return type from the arguments array.
+     * @param {Array} args - The arguments array.
+     * @returns {Function} The return type.
+     */
+    getReturnType(args) {
+        return args[args.length - 1].constructor
+    }
+
+    /**
+     * Creates parameter expressions from argument types.
+     * @param {Array} argsTypes - The argument types.
+     * @returns {Array} The parameter expressions.
+     */
+    createParameters(argsTypes) {
+        return argsTypes.map((type, index) => ({ name: `arg${index}`, type }))
+    }
+
+    /**
+     * Creates an array of arguments for the delegate.
+     * @param {string} delegateGuid - The delegate identifier.
+     * @param {Array} parameters - The parameter expressions.
+     * @returns {Array} The arguments array.
+     */
+    createArgsArray(delegateGuid, parameters) {
+        return [delegateGuid, ...parameters.map((param) => param.name)]
+    }
+
+    /**
+     * Creates a command expression.
+     * @param {string} callingRuntimeName - The runtime name.
+     * @param {Array} payload - The arguments array.
+     * @returns {Object} The command object.
+     */
+    createCommand(callingRuntimeName, payload) {
+        return {
+            runtimeName: callingRuntimeName,
+            type: CommandType.InvokeDelegate,
+            payload,
+        }
+    }
+
+    /**
+     * Creates a method call to execute the command.
+     * @param {Command} command - The command object.
+     * @returns {Object} The response object.
+     */
+    createExecuteCall(command) {
+        return this.interpreter.execute(command, new InMemoryConnectionData())
+    }
+
+    /**
+     * Retrieves the response payload from the execution call.
+     * @param {Object} executeCall - The execution call.
+     * @returns {Array} The response payload.
+     */
+    getResponse(executeCall) {
+        return executeCall.payload
+    }
+
+    /**
+     * Converts the first element of the response to the return type.
+     * @param {Array} response - The response payload.
+     * @param {Function} returnType - The return type.
+     * @returns {*} The converted first element.
+     */
+    convertFirstElement(response, returnType) {
+        return returnType(response[0])
+    }
+
+    /**
+     * Creates a block of expressions for the delegate.
+     * @param {Function} returnType - The return type.
+     * @param {*} convertedFirstElement - The converted first element.
+     * @returns {Object} The block expression.
+     */
+    createBlock(returnType, convertedFirstElement) {
+        return { returnType, body: convertedFirstElement }
+    }
+
+    /**
+     * Creates a delegate type.
+     * @param {Array} parameters - The parameter expressions.
+     * @param {Function} returnType - The return type.
+     * @returns {Function} The delegate type.
+     */
+    createDelegateType(parameters, returnType) {
+        return (...args) => {
+            if (args.length !== parameters.length) {
+                throw new Error('Invalid argument count.')
+            }
+            return returnType
+        }
+    }
+}
+
+module.exports = new PassDelegateHandler()

package/lib/sdk/RuntimeContext.js

@@ -1,6 +1,6 @@
-const { ConnectionType, CommandType, ExceptionThrower, Command, Interpreter } = require('@javonet/core')
+/* eslint-disable no-unused-private-class-members */
+const { Interpreter, RuntimeContext: RuntimeContextCore } = require('@javonet/core')
 const GeneratorHandler = require('../core/generator/handler/GeneratorHandler')
-const { InvocationWsContext, InvocationContext } = require('./InvocationContext')
 
 /**
  * Represents a single context which allows interaction with a selected technology.
@@ -13,17 +13,17 @@ const { InvocationWsContext, InvocationContext } = require('./InvocationContext'
  * @see [Javonet Guides]{@link https://www.javonet.com/guides/v2/javascript/foundations/runtime-context}
  * @class
  */
-class RuntimeContext {
+class RuntimeContext extends RuntimeContextCore {
     static memoryRuntimeContexts = new Map()
     static networkRuntimeContexts = new Map()
     static webSocketRuntimeContexts = new Map()
     #currentCommand
     #responseCommand
     #interpreter
-    // eslint-disable-next-line no-unused-private-class-members
     #generatorHandler
 
     constructor(runtimeName, connectionData) {
+        super()
         this.runtimeName = runtimeName
         this.connectionData = connectionData
         this.#currentCommand = null
@@ -31,222 +31,6 @@ class RuntimeContext {
         this.#interpreter = new Interpreter()
         this.#generatorHandler = new GeneratorHandler()
     }
-
-    static getInstance(runtimeName, connectionData) {
-        switch (connectionData.connectionType) {
-            case ConnectionType.IN_MEMORY:
-                if (runtimeName in RuntimeContext.memoryRuntimeContexts) {
-                    let runtimeCtx = RuntimeContext.memoryRuntimeContexts[runtimeName]
-                    runtimeCtx.currentCommand = null
-                    return runtimeCtx
-                } else {
-                    let runtimeCtx = new RuntimeContext(runtimeName, connectionData)
-                    RuntimeContext.memoryRuntimeContexts[runtimeName] = 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
-                    return runtimeCtx
-                } else {
-                    let runtimeCtx = new RuntimeContext(runtimeName, connectionData)
-                    RuntimeContext.networkRuntimeContexts[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
-                    return runtimeCtx
-                } else {
-                    let runtimeCtx = new RuntimeContext(runtimeName, connectionData)
-                    RuntimeContext.webSocketRuntimeContexts[key2] = runtimeCtx
-                    return runtimeCtx
-                }
-            }
-            default:
-                throw new Error('Invalid connection type')
-        }
-    }
-
-    /**
-     * Executes the current command. The initial state of RuntimeContext is non-materialized,
-     * wrapping either a single command or a chain of recursively nested commands.
-     * Commands become nested through each invocation of methods on RuntimeContext.
-     * Each invocation triggers the creation of a new RuntimeContext instance wrapping the current command with a new parent command.
-     * The developer can decide at any moment of the materialization for the context, taking full control of the chunks of the expression being transferred and processed on the target runtime.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
-     * @method
-     */
-    execute() {
-        this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.connectionData)
-        this.#currentCommand = null
-        if (this.#responseCommand.commandType === CommandType.Exception) {
-            throw ExceptionThrower.throwException(this.#responseCommand)
-        }
-    }
-
-    /**
-     * Adds a reference to a library. Javonet allows you to reference and use modules or packages written in various languages.
-     * This method allows you to use any library from all supported technologies. The necessary libraries need to be referenced.
-     * The argument is a relative or full path to the library. If the library has dependencies on other libraries, the latter needs to be added first.
-     * After referencing the library, any objects stored in this package can be used. Use static classes, create instances, call methods, use fields and properties, and much more.
-     * @param {string} libraryPath - The relative or full path to the library.
-     * @returns {RuntimeContext} RuntimeContext instance.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/getting-started/adding-references-to-libraries)
-     * @method
-     */
-    loadLibrary(libraryPath) {
-        let localCommand = new Command(this.runtimeName, CommandType.LoadLibrary, [libraryPath])
-        this.#currentCommand = this.#buildCommand(localCommand)
-        this.execute()
-        return this
-    }
-
-    /**
-     * Retrieves a reference to a specific type. The type can be a class, interface or enum. The type can be retrieved from any referenced library.
-     * @param {string} typeName - The full name of the type.
-     * @param {...any} args - The arguments to be passed, if needed
-     * @returns {InvocationContext} InvocationContext instance, that wraps the command to get the type.
-     * @method
-     */
-    getType(typeName, ...args) {
-        let localCommand = new Command(this.runtimeName, CommandType.GetType, [typeName, ...args])
-        this.#currentCommand = null
-        if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
-            return new InvocationWsContext(
-                this.runtimeName,
-                this.connectionData,
-                this.#buildCommand(localCommand)
-            )
-        }
-        return new InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand))
-    }
-
-    /**
-     * Casts the provided value to a specific type. This method is used when invoking methods that require specific types of arguments.
-     * The arguments include the target type and the value to be cast. The target type must be retrieved from the called runtime using the getType method.
-     * After casting the value, it can be used as an argument when invoking methods.
-     * @param {...any} args - The target type and the value to be cast.
-     * @returns {InvocationContext} InvocationContext instance that wraps the command to cast the value.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/casting/casting)
-     * @method
-     */
-    cast(...args) {
-        let localCommand = new Command(this.runtimeName, CommandType.Cast, args)
-        this.#currentCommand = null
-        if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
-            return new InvocationWsContext(
-                this.runtimeName,
-                this.connectionData,
-                this.#buildCommand(localCommand)
-            )
-        }
-        return new InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand))
-    }
-
-    /**
-     * Retrieves a specific item from an enum type. This method is used when working with enums from the called runtime.
-     * The arguments include the enum type and the name of the item. The enum type must be retrieved from the called runtime using the getType method.
-     * After retrieving the item, it can be used as an argument when invoking methods or for other operations.
-     * @param {...any} args - The enum type and the name of the item.
-     * @returns {InvocationContext} InvocationContext instance that wraps the command to get the enum item.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/enums/using-enum-type)
-     * @method
-     */
-    getEnumItem(...args) {
-        let localCommand = new Command(this.runtimeName, CommandType.GetEnumItem, args)
-        this.#currentCommand = null
-        if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
-            return new InvocationWsContext(
-                this.runtimeName,
-                this.connectionData,
-                this.#buildCommand(localCommand)
-            )
-        }
-        return new InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand))
-    }
-
-    /**
-     * Creates a reference type argument that can be passed to a method with a ref parameter modifier. This method is used when working with methods from the called runtime that require arguments to be passed by reference.
-     * The arguments include the value and optionally the type of the reference. The type must be retrieved from the called runtime using the getType method.
-     * After creating the reference, it can be used as an argument when invoking methods.
-     * @param {...any} args - The value and optionally the type of the reference.
-     * @returns {InvocationContext} InvocationContext instance that wraps the command to create a reference as ref.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/methods-arguments/passing-arguments-by-reference-with-ref-keyword)
-     * @method
-     */
-    asRef(...args) {
-        let localCommand = new Command(this.runtimeName, CommandType.AsRef, args)
-        this.#currentCommand = null
-        if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
-            return new InvocationWsContext(
-                this.runtimeName,
-                this.connectionData,
-                this.#buildCommand(localCommand)
-            )
-        }
-        return new InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand))
-    }
-
-    /**
-     * Creates a reference type argument that can be passed to a method with an out parameter modifier. This method is used when working with methods from the called runtime that require arguments to be passed by reference.
-     * The arguments include the value and optionally the type of the reference. The type must be retrieved from the called runtime using the getType method.
-     * After creating the reference, it can be used as an argument when invoking methods.
-     * @param {...any} args - The value and optionally the type of the reference.
-     * @returns {InvocationContext} InvocationContext instance that wraps the command to create a reference as out.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/methods-arguments/passing-arguments-by-reference-with-out-keyword |Passing Arguments by Reference with out Keyword Guide)
-     * @method
-     */
-    asOut(...args) {
-        let localCommand = new Command(this.runtimeName, CommandType.AsOut, args)
-        this.#currentCommand = null
-        if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
-            return new InvocationWsContext(
-                this.runtimeName,
-                this.connectionData,
-                this.#buildCommand(localCommand)
-            )
-        }
-        return new InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand))
-    }
-
-    #buildCommand = function (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) {
-        // eslint-disable-next-line valid-typeof
-        if (typeof payloadItem === 'Command' || payloadItem instanceof Command) {
-            for (let i = 0; i < payloadItem.payload.length; i++) {
-                payloadItem.payload[i] = this.#encapsulatePayloadItem(payloadItem.payload[i])
-            }
-            return payloadItem
-            // eslint-disable-next-line valid-typeof
-        } else if (typeof payloadItem === 'InvocationContext' || payloadItem instanceof InvocationContext) {
-            return payloadItem.get_current_command()
-        } else if (payloadItem instanceof Array) {
-            for (let i = 0; i < payloadItem.length; i++) {
-                payloadItem[i] = this.#encapsulatePayloadItem(payloadItem[i])
-            }
-            return new Command(this.runtimeName, CommandType.Array, payloadItem)
-        } else {
-            return new Command(this.runtimeName, CommandType.Value, [payloadItem])
-        }
-    }
-
-    healthCheck() {
-        let localCommand = new Command(this.runtimeName, CommandType.Value, ['health_check'])
-        this.#currentCommand = this.#buildCommand(localCommand)
-        this.execute()
-    }
 }
 
 module.exports = RuntimeContext