javonet-nodejs-sdk 2.6.1 → 2.6.3

package/lib/core/handler/ArrayReferenceHandler.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class ArrayReferenceHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+

package/lib/core/handler/AsKwargsHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class AsKwargsHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}

package/lib/core/handler/AsOutHandler.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class AsOutHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+

package/lib/core/handler/AsRefHandler.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class AsRefHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+

package/lib/core/handler/CreateNullHandler.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class CreateNullHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+

package/lib/core/handler/ExceptionHandler.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class ExceptionHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+

package/lib/core/handler/GenerateLibHandler.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class GenerateLibHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+

package/lib/core/handler/GetAsyncOperationResultHandler.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class GetAsyncOperationResultHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+

package/lib/core/handler/GetEnumItemHandler.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class GetEnumItemHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+

package/lib/core/handler/GetEnumNameHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class GetEnumNameHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}

package/lib/core/handler/GetEnumValueHandler.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class GetEnumValueHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+

package/lib/core/handler/GetGlobalFieldHandler.js

@@ -0,0 +1,44 @@
+import { AbstractHandler } from './AbstractHandler.js'
+
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
+class GetGlobalFieldHandler extends AbstractHandler {
+    requiredParametersCount = 1
+
+    constructor() {
+        super()
+    }
+
+    /**
+     * @param {Command} command
+     * @returns {any}
+     */
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Invoke Global Field parameters mismatch')
+            }
+            const { payload } = command
+            const fieldName = payload[0]
+
+            if (fieldName in global && typeof global[fieldName] !== 'function') {
+                return global[fieldName]
+            } else {
+                const fields = Object.getOwnPropertyNames(global).filter(
+                    (property) => typeof global[property] !== 'function'
+                )
+                let message = `Field ${fieldName} not found in global. Available fields:\n`
+                fields.forEach((field) => {
+                    message += `${field}\n`
+                })
+                throw new Error(message)
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+export { GetGlobalFieldHandler }

package/lib/core/handler/GetModuleHandler.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class GetModuleHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}

package/lib/core/handler/GetRefValueHandler.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class GetRefValueHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+

package/lib/core/handler/GetResultTypeHandler.js

@@ -0,0 +1,29 @@
+// @ts-check
+import { TypesHandler } from '../../utils/TypesHandler.js'
+import { AbstractHandler } from './AbstractHandler.js'
+
+/**
+ * @typedef {import('../../utils/Command.js').Command} Command
+ */
+
+/**
+ * GetResultTypeHandler class handles the conversion of JType to Type.
+ */
+class GetResultTypeHandler extends AbstractHandler {
+    constructor() {
+        super()
+        /** @type {number} */
+        this.requiredParametersCount = 1
+    }
+
+    /**
+     * Processes the given command to convert JType to Type.
+     * @param {Command} command - The command to process.
+     * @returns {any} The converted type.
+     */
+    process(command) {
+        return command.payload[0].constructor.name
+    }
+}
+
+export { GetResultTypeHandler }

package/lib/core/handler/Handler.js

@@ -2,34 +2,56 @@
 import { ReferencesCache } from '../referenceCache/ReferencesCache.js'
 import { ValueHandler } from './ValueHandler.js'
 import { LoadLibraryHandler } from './LoadLibraryHandler.js'
-import { GetTypeHandler } from './GetTypeHandler.js'
 import { InvokeStaticMethodHandler } from './InvokeStaticMethodHandler.js'
 import { GetStaticFieldHandler } from './GetStaticFieldHandler.js'
 import { SetStaticFieldHandler } from './SetStaticFieldHandler.js'
-import { ResolveReferenceHandler } from './ResolveReferenceHandler.js'
 import { CreateClassInstanceHandler } from './CreateClassInstanceHandler.js'
-import { GetInstanceFieldHandler } from './GetInstanceFieldHandler.js'
-import { SetInstanceFieldHandler } from './SetInstanceFieldHandler.js'
+import { GetTypeHandler } from './GetTypeHandler.js'
+import { ResolveReferenceHandler } from './ResolveReferenceHandler.js'
+import { GetModuleHandler } from './GetModuleHandler.js';
 import { InvokeInstanceMethodHandler } from './InvokeInstanceMethodHandler.js'
-import { DestructReferenceHandler } from './DestructReferenceHandler.js'
+import { ExceptionHandler } from './ExceptionHandler.js';
+import { HeartBeatHandler } from './HeartBeatHandler.js';
 import { CastingHandler } from './CastingHandler.js'
+import { GetInstanceFieldHandler } from './GetInstanceFieldHandler.js'
+import { OptimizeHandler } from './OptimizeHandler.js';
+import { GenerateLibHandler } from './GenerateLibHandler.js';
+import { InvokeGlobalFunctionHandler } from './InvokeGlobalFunctionHandler.js'
+import { DestructReferenceHandler } from './DestructReferenceHandler.js'
+import { ArrayReferenceHandler } from './ArrayReferenceHandler.js';
 import { ArrayGetItemHandler } from './ArrayGetItemHandler.js'
 import { ArrayGetSizeHandler } from './ArrayGetSizeHandler.js'
 import { ArrayGetRankHandler } from './ArrayGetRankHandler.js'
 import { ArraySetItemHandler } from './ArraySetItemHandler.js'
 import { ArrayHandler } from './ArrayHandler.js'
-import { EnableNamespaceHandler } from './EnableNamespaceHandler.js'
-import { EnableTypeHandler } from './EnableTypeHandler.js'
-import { GetStaticMethodAsDelegateHandler } from './GetStaticMethodAsDelegateHandler.js'
-import { GetInstanceMethodAsDelegateHandler } from './GetInstanceMethodAsDelegateHandler.js'
-import { PassDelegateHandler } from './PassDelegateHandler.js'
-import { InvokeDelegateHandler } from './InvokeDelegateHandler.js'
-import { InvokeGlobalFunctionHandler } from './InvokeGlobalFunctionHandler.js'
+import { RetrieveArrayHandler } from './RetrieveArrayHandler.js';
+import { SetInstanceFieldHandler } from './SetInstanceFieldHandler.js'
+import { InvokeGenericStaticMethodHandler } from './InvokeGenericStaticMethodHandler.js';
+import { InvokeGenericMethodHandler } from './InvokeGenericMethodHandler.js';
+import { GetEnumItemHandler } from './GetEnumItemHandler.js';
+import { GetEnumNameHandler } from './GetEnumNameHandler.js';
+import { GetEnumValueHandler } from './GetEnumValueHandler.js';
+import { AsRefHandler } from './AsRefHandler.js';
+import { AsOutHandler } from './AsOutHandler.js';
+import { GetRefValueHandler } from './GetRefValueHandler.js';
+import { EnableNamespaceHandler } from './EnableNamespaceHandler.js';
+import { EnableTypeHandler } from './EnableTypeHandler.js';
+import { CreateNullHandler } from './CreateNullHandler.js';
+import { GetStaticMethodAsDelegateHandler } from './GetStaticMethodAsDelegateHandler.js';
+import { GetInstanceMethodAsDelegateHandler } from './GetInstanceMethodAsDelegateHandler.js';
+import { PassDelegateHandler } from './PassDelegateHandler.js';
+import { InvokeDelegateHandler } from './InvokeDelegateHandler.js';
+import { ConvertTypeHandler } from './ConvertTypeHandler.js';
+import { AddEventListenerHandler } from './AddEventListenerHandler.js';
+import { PluginWrapperHandler } from './PluginWrapperHandler.js';
+import { GetAsyncOperationResultHandler } from './GetAsyncOperationResultHandler.js';
+import { AsKwargsHandler } from './AsKwargsHandler.js';
+import { GetResultTypeHandler } from './GetResultTypeHandler.js';
+import { GetGlobalFieldHandler } from './GetGlobalFieldHandler.js';
 import { CommandType } from '../../utils/CommandType.js'
 import { Command } from '../../utils/Command.js'
 import { TypesHandler } from '../../utils/TypesHandler.js'
 import { ExceptionSerializer } from '../../utils/exception/ExceptionSerializer.js'
-import { ConvertTypeHandler } from './ConvertTypeHandler.js'
 import { AbstractHandler } from './AbstractHandler.js'
 
 /**
@@ -43,29 +65,51 @@ const handlers = {
     [CommandType.Value]: new ValueHandler(),
     [CommandType.LoadLibrary]: new LoadLibraryHandler(),
     [CommandType.InvokeStaticMethod]: new InvokeStaticMethodHandler(),
-    [CommandType.GetType]: new GetTypeHandler(),
     [CommandType.GetStaticField]: new GetStaticFieldHandler(),
     [CommandType.SetStaticField]: new SetStaticFieldHandler(),
     [CommandType.CreateClassInstance]: new CreateClassInstanceHandler(),
+    [CommandType.GetType]: new GetTypeHandler(),
     [CommandType.Reference]: new ResolveReferenceHandler(),
+    [CommandType.GetModule]: new GetModuleHandler(),
+    [CommandType.InvokeInstanceMethod]: new InvokeInstanceMethodHandler(),
+    [CommandType.Exception]: new ExceptionHandler(),
+    [CommandType.HeartBeat]: new HeartBeatHandler(),
     [CommandType.Cast]: new CastingHandler(),
     [CommandType.GetInstanceField]: new GetInstanceFieldHandler(),
-    [CommandType.SetInstanceField]: new SetInstanceFieldHandler(),
-    [CommandType.InvokeInstanceMethod]: new InvokeInstanceMethodHandler(),
+    [CommandType.Optimize]: new OptimizeHandler(),
+    [CommandType.GenerateLib]: new GenerateLibHandler(),
+    [CommandType.InvokeGlobalFunction]: new InvokeGlobalFunctionHandler(),
     [CommandType.DestructReference]: new DestructReferenceHandler(),
+    [CommandType.ArrayReference]: new ArrayReferenceHandler(),
     [CommandType.ArrayGetItem]: new ArrayGetItemHandler(),
     [CommandType.ArrayGetSize]: new ArrayGetSizeHandler(),
     [CommandType.ArrayGetRank]: new ArrayGetRankHandler(),
     [CommandType.ArraySetItem]: new ArraySetItemHandler(),
     [CommandType.Array]: new ArrayHandler(),
+    [CommandType.RetrieveArray]: new RetrieveArrayHandler(),
+    [CommandType.SetInstanceField]: new SetInstanceFieldHandler(),
+    [CommandType.InvokeGenericStaticMethod]: new InvokeGenericStaticMethodHandler(),
+    [CommandType.InvokeGenericMethod]: new InvokeGenericMethodHandler(),
+    [CommandType.GetEnumItem]: new GetEnumItemHandler(),
+    [CommandType.GetEnumName]: new GetEnumNameHandler(),
+    [CommandType.GetEnumValue]: new GetEnumValueHandler(),
+    [CommandType.AsRef]: new AsRefHandler(),
+    [CommandType.AsOut]: new AsOutHandler(),
+    [CommandType.GetRefValue]: new GetRefValueHandler(),
     [CommandType.EnableNamespace]: new EnableNamespaceHandler(),
     [CommandType.EnableType]: new EnableTypeHandler(),
+    [CommandType.CreateNull]: new CreateNullHandler(),
     [CommandType.GetStaticMethodAsDelegate]: new GetStaticMethodAsDelegateHandler(),
     [CommandType.GetInstanceMethodAsDelegate]: new GetInstanceMethodAsDelegateHandler(),
     [CommandType.PassDelegate]: new PassDelegateHandler(),
     [CommandType.InvokeDelegate]: new InvokeDelegateHandler(),
     [CommandType.ConvertType]: new ConvertTypeHandler(),
-    [CommandType.InvokeGlobalFunction]: new InvokeGlobalFunctionHandler(),
+    [CommandType.AddEventListener]: new AddEventListenerHandler(),
+    [CommandType.PluginWrapper]: new PluginWrapperHandler(),
+    [CommandType.GetAsyncOperationResult]: new GetAsyncOperationResultHandler(),
+    [CommandType.AsKwargs]: new AsKwargsHandler(),
+    [CommandType.GetResultType]: new GetResultTypeHandler(),
+    [CommandType.GetGlobalField]: new GetGlobalFieldHandler(),
 }
 
 class Handler {

package/lib/core/handler/HeartBeatHandler.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class HeartBeatHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+

package/lib/core/handler/InvokeGenericMethodHandler.js

@@ -0,0 +1,13 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class InvokeGenericMethodHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+
+

package/lib/core/handler/InvokeGenericStaticMethodHandler.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class InvokeGenericStaticMethodHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+

package/lib/core/handler/OptimizeHandler.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class OptimizeHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+

package/lib/core/handler/PluginWrapperHandler.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class PluginWrapperHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+

package/lib/core/handler/RetrieveArrayHandler.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { AbstractHandler } from './AbstractHandler.js';
+
+export class RetrieveArrayHandler extends AbstractHandler {
+    /**
+     * @param {any} command
+     */
+    handleCommand(command) {
+        throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+    }
+}
+

package/lib/sdk/ActivatorDetails.js

@@ -0,0 +1,15 @@
+/**
+ * Details for activating a type with constructor arguments
+ */
+class ActivatorDetails {
+    /**
+     * @param {Function} type - The constructor function/class
+     * @param {any[]} [args] - Arguments to pass to constructor
+     */
+    constructor(type, args = []) {
+        this.type = type
+        this.arguments = args
+    }
+}
+
+export { ActivatorDetails }

package/lib/sdk/InvocationContext.js

@@ -395,6 +395,29 @@ class InvocationContext {
         return this.#createInstanceContext(localCommand)
     }
 
+    /**
+     * Retrieves the type of the object from the target runtime.
+     * @returns {string} The type of the object.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/type-handling/getting-object-type)
+     * @method
+     */
+    getResultType() {
+        const localCommand = new Command(this.#runtimeName, CommandType.GetResultType, [])
+        const invocationContext = new InvocationContext(this.#runtimeName, this.#connectionData, this.#buildCommand(localCommand))
+        const result = invocationContext.execute().getValue()
+        return /** @type {string} */ (result)
+    }
+
+    /**
+     * Retrieves the name of the runtime where the command is executed.
+     * @returns {number} The name of the runtime.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/runtime-name)
+     * @method
+     */
+    getRuntimeName() {
+        return this.#runtimeName
+    }
+
     /**
      * Retrieves an array from the target runtime.
      * @returns {InvocationContext} A new InvocationContext instance that wraps the command to retrieve the array.
@@ -556,6 +579,70 @@ class InvocationWsContext extends InvocationContext {
 
         return new InvocationWsContext(this.#runtimeName, this.#connectionData, this.#responseCommand, true)
     }
+
+    /**
+     * Retrieves the type of the object from the target runtime.
+     * @returns {Promise<string>} The type of the object.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/type-handling/getting-object-type)
+     * @async
+     * @method
+     */
+    // @ts-expect-error
+    async getResultType() {
+        const localCommand = new Command(this.#runtimeName, CommandType.GetResultType, [])
+        const invocationContext = new InvocationWsContext(this.#runtimeName, this.#connectionData, this.#buildCommand(localCommand))
+        const result = await invocationContext.execute()
+        return /** @type {string} */ (result.getValue())
+    }
+
+    /**
+     * @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)
+    }
+
+    /**
+     * @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++) {
+                payloadItem.payload[i] = this.#encapsulatePayloadItem(payloadItem.payload[i])
+            }
+            return payloadItem
+            // eslint-disable-next-line valid-typeof
+        } else if (payloadItem instanceof InvocationContext || payloadItem instanceof InvocationWsContext) {
+            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)
+        } else if (typeof payloadItem === 'function') {
+            let newArray = new Array(payloadItem.length + 1)
+            for (let i = 0; i < newArray.length; i++) {
+                newArray[i] = typeof Object
+            }
+            const args = [delegatesCacheInstance.addDelegate(payloadItem), RuntimeName.Nodejs].push(
+                ...newArray
+            )
+            return new Command(this.#runtimeName, CommandType.PassDelegate, args)
+        } 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
+            )
+        }
+    }
 }
 
 export { InvocationContext, InvocationWsContext }

package/lib/sdk/Javonet.js

@@ -2,13 +2,12 @@
 import { ConfigRuntimeFactory } from './ConfigRuntimeFactory.js'
 import { RuntimeFactory } from './RuntimeFactory.js'
 import { InMemoryConnectionData } from '../utils/connectionData/InMemoryConnectionData.js'
-import { isNodejsRuntime, getRuntimeExtension, getRequire } from '../utils/Runtime.js'
+import { isNodejsRuntime,  getRequire } from '../utils/Runtime.js'
 import { CommandSerializer } from '../core/protocol/CommandSerializer.js'
 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 */

package/lib/sdk/RuntimeContext.js

@@ -284,6 +284,27 @@ class RuntimeContext {
         return new InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand))
     }
 
+    /**
+     * Retrieves the value of an global field from the target runtime.
+     * @param {string} fieldName - The name of the field to get.
+     * @returns {InvocationContext} A new InvocationContext instance that wraps the command to get the global field.
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/fields-and-properties/getting-values-for-global-fields)
+     * @method
+     */
+    getGlobalField(fieldName) {
+        let localCommand = new Command(this.runtimeName, CommandType.GetGlobalField, [fieldName])
+        this.#currentCommand = null
+        if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+            // @ts-expect-error
+            return new InvocationWsContext(
+                this.runtimeName,
+                this.connectionData,
+                this.#buildCommand(localCommand)
+            )
+        }
+        return new InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand))
+    }
+
     /**
      * Invokes a function from the called runtime. This method is used when working with functions from the called runtime.
      * The arguments include the function name and the arguments to be passed to the function.