javonet-nodejs-sdk 2.6.7 → 2.6.9

package/dist/sdk/InvocationContext.cjs

@@ -25,10 +25,10 @@ var import_DelegatesCache = require("../core/delegatesCache/DelegatesCache.cjs")
 var import_Interpreter = require("../core/interpreter/Interpreter.cjs");
 var import_Command = require("../utils/Command.cjs");
 var import_CommandType = require("../utils/CommandType.cjs");
-var import_ConnectionType = require("../utils/ConnectionType.cjs");
 var import_ExceptionThrower = require("../utils/exception/ExceptionThrower.cjs");
 var import_RuntimeName = require("../utils/RuntimeName.cjs");
 var import_TypesHandler = require("../utils/TypesHandler.cjs");
+var import_uuid = require("uuid");
 class InvocationContext {
   /** @type {RuntimeNameType} */
   #runtimeName;
@@ -36,12 +36,16 @@ class InvocationContext {
   #connectionData;
   /** @type {Command | null} */
   #currentCommand = null;
-  /** @type {Command | Promise<Command> | null} */
+  /** @type {Command | null} */
   #responseCommand = null;
   /** @type {boolean} */
   #isExecuted = false;
   /** @type {Interpreter | null} */
   #interpreter = null;
+  /** @type {string | null} */
+  #guid = null;
+  // Static map holding contexts waiting for materialization (guid -> InvocationContext)
+  static _invocationContexts = /* @__PURE__ */ new Map();
   /**
    *
    * @param {RuntimeNameType} runtimeName
@@ -56,6 +60,13 @@ class InvocationContext {
     this.#responseCommand = null;
     this.#isExecuted = isExecuted;
     this.#interpreter = null;
+    this.#guid = (0, import_uuid.v4)();
+  }
+  /**
+   * @returns {string} guid of this InvocationContext
+   */
+  getGuid() {
+    return this.#guid;
   }
   /**
    * @param {Command} localCommand
@@ -84,68 +95,48 @@ class InvocationContext {
   //        this.execute();
   //    }
   //}
-  [Symbol.iterator] = () => {
+  /**
+   * Async iterator for InvocationContext arrays
+   * Use: for await (const item of invocationContext) { ... }
+   * @returns {AsyncGenerator<InvocationContext, void, unknown>}
+   */
+  async *[Symbol.asyncIterator]() {
     if (this.#currentCommand?.commandType !== import_CommandType.CommandType.Reference) {
       throw new Error("Object is not iterable");
     }
-    let position = -1;
-    let arraySize = 0;
-    const sizeCtx = (
-      /** @type {any} */
-      this.getSize().execute()
-    );
-    if (sizeCtx instanceof Promise) {
-      sizeCtx.then((ctx) => {
-        arraySize = Number(ctx.getValue());
-      });
-    } else {
-      arraySize = Number(sizeCtx.getValue());
+    const sizeCtx = await this.getSize().execute();
+    const arraySize = Number(sizeCtx.getValue());
+    for (let position = 0; position < arraySize; position++) {
+      yield this.getIndex(position);
     }
-    return {
-      next: () => ({
-        value: this.getIndex(++position),
-        done: position >= arraySize
-      })
-    };
-  };
+  }
   /**
    * Executes the current command.
-   * Because invocation context is building the intent of executing particular expression on target environment, we call the initial state of invocation context as non-materialized.
-   * The non-materialized context wraps either single command or chain of recursively nested commands.
-   * 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 {Promise<InvocationContext> | InvocationContext} the InvocationContext after executing the command.
-   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
+   * Returns the InvocationContext after executing the command.
+   * @returns {Promise<InvocationContext>}
    * @method
    */
-  execute() {
+  async execute() {
     if (this.#currentCommand === null) {
       throw new Error("currentCommand is undefined in Invocation Context execute method");
     }
     if (!this.#interpreter) {
       this.#interpreter = new import_Interpreter.Interpreter();
     }
-    this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.#connectionData);
-    const handleResponse = (resolvedResponse) => {
-      if (!resolvedResponse) {
-        throw new Error("responseCommand is undefined in Invocation Context execute method");
-      }
-      if (resolvedResponse.commandType === import_CommandType.CommandType.Exception) {
-        throw import_ExceptionThrower.ExceptionThrower.throwException(resolvedResponse);
-      }
-      if (resolvedResponse.commandType === import_CommandType.CommandType.CreateClassInstance) {
-        this.#currentCommand = resolvedResponse;
-        this.#isExecuted = true;
-        return this;
-      }
-      return new InvocationContext(this.#runtimeName, this.#connectionData, resolvedResponse, true);
-    };
-    if (this.#responseCommand instanceof Promise) {
-      return this.#responseCommand.then(handleResponse);
-    } else {
-      return handleResponse(this.#responseCommand);
+    this.#responseCommand = await this.#interpreter.execute(this.#currentCommand, this.#connectionData);
+    if (!this.#responseCommand) {
+      throw new Error("responseCommand is undefined in Invocation Context execute method");
+    }
+    if (this.#responseCommand.commandType === import_CommandType.CommandType.Exception) {
+      throw import_ExceptionThrower.ExceptionThrower.throwException(this.#responseCommand);
+    }
+    this.#responseCommand = this.#processUpdateInvocationContextCommands(this.#responseCommand);
+    if (this.#responseCommand.commandType === import_CommandType.CommandType.CreateClassInstance) {
+      this.#currentCommand = this.#responseCommand;
+      this.#isExecuted = true;
+      return this;
     }
+    return new InvocationContext(this.#runtimeName, this.#connectionData, this.#responseCommand, true);
   }
   /**
    * Invokes a static method on the target runtime.
@@ -187,14 +178,24 @@ class InvocationContext {
   }
   /**
    * Creates a new instance of a class in the target runtime.
+   * Adds the newly created context to the static invocation contexts map and
+   * includes the context GUID as the first argument of CreateClassInstance command payload.
    * @param {...any} args - The arguments to pass to the class constructor
    * @returns {InvocationContext} A new InvocationContext instance that wraps the command to create the instance.
-   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/calling-methods/creating-instance-and-calling-instance-methods)
    * @method
    */
   createInstance(...args) {
-    let localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.CreateClassInstance, args);
-    return this.#createInstanceContext(localCommand);
+    const dummyCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.CreateClassInstance, [
+      ...args
+    ]);
+    const createInstanceContext = new InvocationContext(this.#runtimeName, this.#connectionData, dummyCommand);
+    let localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.CreateClassInstance, [
+      createInstanceContext.getGuid(),
+      ...args
+    ]);
+    createInstanceContext.#currentCommand = this.#buildCommand(localCommand);
+    InvocationContext._invocationContexts.set(createInstanceContext.getGuid(), createInstanceContext);
+    return createInstanceContext;
   }
   /**
    * Retrieves the value of an instance field from the target runtime.
@@ -382,21 +383,19 @@ class InvocationContext {
   }
   /**
    * Retrieves the type of the object from the target runtime.
-   * @returns {Promise<string> | string} The type of the object.
+   * @returns {Promise<string>} The type of the object.
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/type-handling/getting-object-type)
    * @method
    */
-  getResultType() {
+  async getResultType() {
     const localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.GetResultType, []);
     const invocationContext = new InvocationContext(
       this.#runtimeName,
       this.#connectionData,
       this.#buildCommand(localCommand)
     );
-    const execCtx = invocationContext.execute();
-    const extract = (invCtx) => String(invCtx.getValue());
-    console.log(execCtx);
-    return execCtx instanceof Promise ? execCtx.then(extract) : extract(execCtx);
+    const execCtx = await invocationContext.execute();
+    return String(execCtx.getValue());
   }
   /**
    * Retrieves the name of the runtime where the command is executed.
@@ -409,21 +408,33 @@ class InvocationContext {
   }
   /**
    * Retrieves an array from the target runtime.
+   * @async
    * @returns {Promise<any[]>}
    * @method
    */
-  retrieveArray() {
+  async retrieveArray() {
     const localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.RetrieveArray, []);
     const localInvCtx = new InvocationContext(
       this.#runtimeName,
       this.#connectionData,
       this.#buildCommand(localCommand)
     );
-    localInvCtx.execute();
-    const extract = (respCommand) => {
-      return respCommand.payload;
+    await localInvCtx.execute();
+    const resolve = (item) => {
+      return item?.commandType === import_CommandType.CommandType.Reference ? new InvocationContext(
+        this.#runtimeName,
+        this.#connectionData,
+        item
+      ) : item;
     };
-    return localInvCtx.#responseCommand instanceof Promise ? localInvCtx.#responseCommand.then(extract) : localInvCtx.#responseCommand?.payload;
+    const respCommand = localInvCtx.#responseCommand;
+    if (!respCommand) {
+      return [];
+    }
+    if (respCommand.payload) {
+      return respCommand.payload.map((item) => resolve(item));
+    }
+    return respCommand.payload || [];
   }
   /**
    * Returns the primitive value from the target runtime. This could be any primitive type in JavaScript,
@@ -465,9 +476,8 @@ class InvocationContext {
       for (let i = 0; i < newArray.length; i++) {
         newArray[i] = typeof Object;
       }
-      const args = [import_DelegatesCache.delegatesCacheInstance.addDelegate(payloadItem), import_RuntimeName.RuntimeName.Nodejs].push(
-        ...newArray
-      );
+      const args = [import_DelegatesCache.delegatesCacheInstance.addDelegate(payloadItem), import_RuntimeName.RuntimeName.Nodejs];
+      args.push(...newArray);
       return new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.PassDelegate, args);
     } else if (import_TypesHandler.TypesHandler.isPrimitiveOrNullOrUndefined(payloadItem)) {
       return new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.Value, [payloadItem]);
@@ -477,6 +487,42 @@ class InvocationContext {
       );
     }
   }
+  /**
+   * Process UpdateInvocationContext commands in the provided responseCommand payload.
+   * For each UpdateInvocationContext command, set the referenced InvocationContext's currentCommand to a Reference command,
+   * remove that InvocationContext from the static map and remove UpdateInvocationContext items from response payload.
+   * @param {Command} responseCommand
+   * @returns {Command}
+   */
+  #processUpdateInvocationContextCommands(responseCommand) {
+    if (!responseCommand?.payload?.length) {
+      return responseCommand;
+    }
+    const commandsToUpdate = responseCommand.payload.filter(
+      (item) => item instanceof import_Command.Command && item.commandType === import_CommandType.CommandType.UpdateInvocationContext
+    );
+    if (commandsToUpdate.length === 0) {
+      return responseCommand;
+    }
+    const updatedPayload = new Set(responseCommand.payload);
+    for (const cmd of commandsToUpdate) {
+      if (cmd.payload?.length >= 2) {
+        const contextGuid = String(cmd.payload[0]);
+        const instanceGuid = cmd.payload[1];
+        const invCtx = InvocationContext._invocationContexts.get(contextGuid);
+        if (invCtx) {
+          invCtx.#currentCommand = new import_Command.Command(invCtx.#runtimeName, import_CommandType.CommandType.Reference, [instanceGuid]);
+          InvocationContext._invocationContexts.delete(contextGuid);
+        }
+      }
+      updatedPayload.delete(cmd);
+    }
+    return new import_Command.Command(
+      responseCommand.runtimeName,
+      responseCommand.commandType,
+      Array.from(updatedPayload)
+    );
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/sdk/Javonet.cjs

@@ -20,6 +20,7 @@ var Javonet_exports = {};
 __export(Javonet_exports, {
   CommandDeserializer: () => import_CommandDeserializer.CommandDeserializer,
   CommandSerializer: () => import_CommandSerializer.CommandSerializer,
+  ComplexTypeResolver: () => import_ComplexTypeResolver.ComplexTypeResolver,
   ConfigPriority: () => import_ConfigPriority.ConfigPriority,
   Javonet: () => Javonet,
   TcpConnectionData: () => import_TcpConnectionData.TcpConnectionData,
@@ -39,6 +40,7 @@ var import_WsConnectionData = require("../utils/connectionData/WsConnectionData.
 var import_UtilsConst = require("../utils/UtilsConst.cjs");
 var import_ConfigSourceResolver = require("./configuration/ConfigSourceResolver.cjs");
 var import_ConfigPriority = require("./configuration/ConfigPriority.cjs");
+var import_ComplexTypeResolver = require("./tools/ComplexTypeResolver.cjs");
 class Javonet {
   /**
    * Initializes Javonet using an in-memory channel on the same machine.
@@ -134,6 +136,7 @@ class Javonet {
 0 && (module.exports = {
   CommandDeserializer,
   CommandSerializer,
+  ComplexTypeResolver,
   ConfigPriority,
   Javonet,
   TcpConnectionData,

package/dist/sdk/RuntimeContext.cjs

@@ -136,10 +136,11 @@ class 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)
+   * @returns {Promise<void>}
    * @method
    */
-  execute() {
-    this.#responseCommand = this.#interpreter?.execute(this.#currentCommand, this.connectionData);
+  async execute() {
+    this.#responseCommand = await this.#interpreter?.execute(this.#currentCommand, this.connectionData);
     this.#currentCommand = null;
     if (this.#responseCommand === void 0) {
       throw new Error("responseCommand is undefined in Runtime Context execute method");
@@ -154,14 +155,14 @@ class RuntimeContext {
    * 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.
+   * @returns {Promise<RuntimeContext>} RuntimeContext instance.
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/getting-started/adding-references-to-libraries)
    * @method
    */
-  loadLibrary(libraryPath) {
+  async loadLibrary(libraryPath) {
     let localCommand = new import_Command.Command(this.runtimeName, import_CommandType.CommandType.LoadLibrary, [libraryPath]);
     this.#currentCommand = this.#buildCommand(localCommand);
-    this.execute();
+    await this.execute();
     return this;
   }
   /**
@@ -296,9 +297,8 @@ class RuntimeContext {
       for (let i = 0; i < newArray.length; i++) {
         newArray[i] = "object";
       }
-      const args = [import_DelegatesCache.delegatesCacheInstance.addDelegate(payloadItem), import_RuntimeName.RuntimeName.Nodejs].push(
-        ...newArray
-      );
+      const args = [import_DelegatesCache.delegatesCacheInstance.addDelegate(payloadItem), import_RuntimeName.RuntimeName.Nodejs];
+      args.push(...newArray);
       return new import_Command.Command(this.runtimeName, import_CommandType.CommandType.PassDelegate, args);
     } else if (import_TypesHandler.TypesHandler.isPrimitiveOrNullOrUndefined(payloadItem)) {
       return new import_Command.Command(this.runtimeName, import_CommandType.CommandType.Value, [payloadItem]);

package/dist/sdk/configuration/ConfigSourceResolver.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,32 +15,39 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var ConfigSourceResolver_exports = {};
 __export(ConfigSourceResolver_exports, {
   ConfigSourceResolver: () => ConfigSourceResolver
 });
 module.exports = __toCommonJS(ConfigSourceResolver_exports);
-var import_fs = __toESM(require("fs"), 1);
-var import_process = __toESM(require("process"), 1);
 var import_ConfigsDictionary = require("./ConfigsDictionary.cjs");
 var import_JsonConfigResolver = require("./configResolvers/JsonConfigResolver.cjs");
 var import_YamlConfigResolver = require("./configResolvers/YamlConfigResolver.cjs");
 var import_ConnectionStringConfigResolver = require("./configResolvers/ConnectionStringConfigResolver.cjs");
+var import_Runtime = require("../../utils/Runtime.cjs");
+const import_meta = {};
+let fs = null;
+let process = null;
+const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class ConfigSourceResolver {
+  /**
+   * @param {import('./ConfigPriority.js').ConfigPriority} priority
+   * @param {string | any} configSource
+   */
   static addConfigs(priority, configSource) {
     console.log(`Adding config from source: ${configSource} with priority '${priority}'`);
-    const configString = ConfigSourceResolver._getConfigSourceAsString(configSource);
-    ConfigSourceResolver._parseConfigsAndAddToCollection(priority, configString);
+    if (configSource && typeof configSource === "object") {
+      import_JsonConfigResolver.JsonConfigResolver.addConfigs(priority, configSource);
+    } else {
+      const configString = ConfigSourceResolver._getConfigSourceAsString(configSource);
+      ConfigSourceResolver._parseConfigsAndAddToCollection(priority, configString);
+    }
   }
+  /**
+   * @param {string} configName
+   * @returns {*}
+   */
   static getConfig(configName) {
     console.log(`Retrieving config ${configName}`);
     return import_ConfigsDictionary.ConfigsDictionary.getConfig(configName);
@@ -50,19 +55,36 @@ class ConfigSourceResolver {
   static clearConfigs() {
     import_ConfigsDictionary.ConfigsDictionary.clearConfigs();
   }
+  /**
+   * @param {string} configSource
+   * @returns {string}
+   */
   static _getConfigSourceAsString(configSource) {
     if (!configSource || configSource.trim() === "") {
       throw new Error("Config source cannot be null or whitespace.");
     }
-    const envValue = import_process.default.env[configSource];
-    if (envValue && envValue.trim() !== "") {
-      configSource = envValue;
-    }
-    if (import_fs.default.existsSync(configSource) && import_fs.default.statSync(configSource).isFile()) {
-      configSource = import_fs.default.readFileSync(configSource, { encoding: "utf-8" });
+    if ((0, import_Runtime.isNodejsRuntime)()) {
+      if (!process) {
+        process = requireDynamic("process");
+      }
+      if (!fs) {
+        fs = requireDynamic("fs");
+      }
+      const envValue = process?.env[configSource];
+      if (envValue && envValue.trim() !== "") {
+        configSource = envValue;
+      }
+      if (fs?.existsSync(configSource) && fs?.statSync(configSource).isFile()) {
+        configSource = fs.readFileSync(configSource, { encoding: "utf-8" });
+      }
     }
     return configSource.trim();
   }
+  /**
+   * @param {import('./ConfigPriority.js').ConfigPriority} priority
+   * @param {string} configString
+   * @returns
+   */
   static _parseConfigsAndAddToCollection(priority, configString) {
     try {
       const jsonObject = JSON.parse(configString);
@@ -78,7 +100,7 @@ class ConfigSourceResolver {
       import_YamlConfigResolver.YamlConfigResolver.addConfigs(priority, configString);
       return;
     } catch (ex) {
-      if (ex.name === "SyntaxError") {
+      if (ex?.name === "SyntaxError") {
       } else {
         console.log("Failed to parse config source as YAML: " + ex);
       }

package/dist/sdk/tools/ComplexTypeResolver.cjs

@@ -21,8 +21,10 @@ __export(ComplexTypeResolver_exports, {
   ComplexTypeResolver: () => ComplexTypeResolver
 });
 module.exports = __toCommonJS(ComplexTypeResolver_exports);
+var import_Primitives = require("../../utils/Primitives.cjs");
 var import_Runtime = require("../../utils/Runtime.cjs");
 var import_RuntimeName = require("../../utils/RuntimeName.cjs");
+var import_Activator = require("../Activator.cjs");
 var import_ActivatorDetails = require("../ActivatorDetails.cjs");
 var import_InvocationContext = require("../InvocationContext.cjs");
 var import_JavaTypeParsingFunctions = require("./typeParsingFunctions/JavaTypeParsingFunctions.cjs");
@@ -31,17 +33,19 @@ var import_NodejsTypeParsingFunctions = require("./typeParsingFunctions/NodejsTy
 var import_PythonTypeParsingFunctions = require("./typeParsingFunctions/PythonTypeParsingFunctions.cjs");
 const import_meta = {};
 const dynamicImport = (0, import_Runtime.getRequire)(import_meta.url);
+const typeParsingFunctions = /* @__PURE__ */ new Map([
+  [import_RuntimeName.RuntimeName.Netcore, import_NetcoreTypeParsingFunctions.NetcoreTypeParsingFunctions],
+  [import_RuntimeName.RuntimeName.Jvm, import_JavaTypeParsingFunctions.JavaTypeParsingFunctions],
+  [import_RuntimeName.RuntimeName.Nodejs, import_NodejsTypeParsingFunctions.NodejsTypeParsingFunctions],
+  [import_RuntimeName.RuntimeName.Python, import_PythonTypeParsingFunctions.PythonTypeParsingFunctions],
+  [import_RuntimeName.RuntimeName.Python27, import_PythonTypeParsingFunctions.PythonTypeParsingFunctions]
+]);
 class ComplexTypeResolver {
   /** @type {Map<string, ActivatorDetails>} */
-  #typeMap = /* @__PURE__ */ new Map();
-  /** @type {Map<number, Map<string, Function>>} */
-  #typeParsingFunctions = /* @__PURE__ */ new Map([
-    [import_RuntimeName.RuntimeName.Netcore, import_NetcoreTypeParsingFunctions.NetcoreTypeParsingFunctions],
-    [import_RuntimeName.RuntimeName.Jvm, import_JavaTypeParsingFunctions.JavaTypeParsingFunctions],
-    [import_RuntimeName.RuntimeName.Nodejs, import_NodejsTypeParsingFunctions.NodejsTypeParsingFunctions],
-    [import_RuntimeName.RuntimeName.Python, import_PythonTypeParsingFunctions.PythonTypeParsingFunctions],
-    [import_RuntimeName.RuntimeName.Python27, import_PythonTypeParsingFunctions.PythonTypeParsingFunctions]
-  ]);
+  #typeMap;
+  constructor() {
+    this.#typeMap = /* @__PURE__ */ new Map();
+  }
   /**
    * Register a custom type mapping
    * @param {string} resultType - The type name from the target runtime
@@ -56,38 +60,40 @@ class ComplexTypeResolver {
   /**
    * Convert InvocationContext result to appropriate JavaScript type
    * @param {InvocationContext} ic - The invocation context
-   * @returns {Promise<any> | any} The converted result
+   * @returns {Promise<any>} The converted result
    */
-  convertResult(ic) {
+  async convertResult(ic) {
     const runtimeName = ic.getRuntimeName();
-    const resultType = ic.getResultType();
-    const runtimeDict = this.#typeParsingFunctions.get(runtimeName);
-    if (runtimeDict) {
-      let parsingFunc = null;
-      if (resultType instanceof Promise) {
-        parsingFunc = resultType.then((result) => {
-          parsingFunc = runtimeDict.get(result);
-        });
-      } else {
-        parsingFunc = runtimeDict.get(resultType);
-      }
-      if (parsingFunc) {
-        return parsingFunc(ic);
-      }
+    const resultType = await ic.getResultType();
+    if (!resultType) {
+      throw new Error("resultType is not valid");
     }
-    let activatorDetails = null;
-    if (resultType instanceof Promise) {
-      activatorDetails = resultType.then((result) => {
-        activatorDetails = this.#typeMap.get(result);
-      });
-    } else {
-      activatorDetails = this.#typeMap.get(resultType);
+    let underlyingType = ComplexTypeResolver.tryGetUnderlyingArrayType(resultType);
+    if (underlyingType !== null) {
+      const { Type } = (
+        /** @type {ActivatorDetails} */
+        this.#typeMap.get(underlyingType)
+      );
+      const complexTypesArray = await ic.retrieveArray();
+      return complexTypesArray.map((item) => import_Activator.Activator.createInstance(Type, item));
     }
+    const parsingFunction = ComplexTypeResolver.tryGetTypeParsingFunction(runtimeName, resultType);
+    if (parsingFunction) {
+      return parsingFunction(ic);
+    }
+    const activatorDetails = this.tryGetValueFromTypeMap(resultType);
     if (!activatorDetails) {
       throw new Error(`No type registered for key '${resultType}'.`);
     }
-    return new /** @type {any} */
-    activatorDetails.type(...activatorDetails.arguments);
+    if (runtimeName === import_RuntimeName.RuntimeName.Nodejs) {
+      const value = await ic.getValue();
+      if (value) {
+        if (value instanceof activatorDetails.Type) {
+          return value;
+        }
+      }
+    }
+    return import_Activator.Activator.createInstance(activatorDetails.Type, activatorDetails.arguments ?? null);
   }
   /**
    * Resolve type from string name and optional module
@@ -121,6 +127,50 @@ class ComplexTypeResolver {
     }
     return typeObj;
   }
+  /**
+   * Attempts to extract the underlying element type from an array type string
+   * @param {string} type - The type string to parse (e.g., "MyType[]")
+   * @returns {string | null} Object indicating success and the element type
+   * @throws {Error} If the array element type is a primitive type
+   */
+  static tryGetUnderlyingArrayType(type) {
+    if (typeof type !== "string" || !type.includes("[")) {
+      return null;
+    }
+    let trimmedType = type.trim();
+    if (!trimmedType) return null;
+    const commaIndex = trimmedType.indexOf(",");
+    if (commaIndex > 0) {
+      trimmedType = trimmedType.substring(0, commaIndex).trim();
+    }
+    const bracketIndex = trimmedType.indexOf("[");
+    if (bracketIndex > 0) {
+      trimmedType = trimmedType.substring(0, bracketIndex).trim();
+    }
+    if (import_Primitives.PrimitiveSet.has(trimmedType)) {
+      throw new Error("Primitive array element types are not supported.");
+    }
+    return trimmedType;
+  }
+  /**
+   * @param {RuntimeName} runtimeName
+   * @param {string} resultType
+   * @returns {any}
+   */
+  static tryGetTypeParsingFunction(runtimeName, resultType) {
+    const runtimeDict = typeParsingFunctions.get(runtimeName);
+    return runtimeDict ? runtimeDict.get(resultType) ?? null : null;
+  }
+  /**
+   * @param {string} resultType
+   * @returns {ActivatorDetails | null}
+   */
+  tryGetValueFromTypeMap(resultType) {
+    if (!resultType) {
+      throw new Error("resultType is not valid");
+    }
+    return this.#typeMap.get(resultType) ?? null;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/types/core/handler/CreateClassInstanceHandler.d.ts

@@ -3,6 +3,14 @@ export type Command = import("../../utils/Command.js").Command;
  * @typedef {import('../../utils/Command.js').Command} Command
  */
 export class CreateClassInstanceHandler extends AbstractHandler {
+    static _invocationContexts: Map<any, any>;
+    static getOrCreateContextDictionary(): Map<any, any>;
+    /**
+     * @param {{ toString: () => any; } | null} value
+     */
+    static isGuid(value: {
+        toString: () => any;
+    } | null): boolean;
     requiredParametersCount: number;
     /**
      * @param {Command} command

package/dist/types/core/handler/Handler.d.ts

@@ -7,8 +7,9 @@ export class Handler {
     interpreter: import("../interpreter/Interpreter.js").Interpreter;
     /**
      * @param {Command} command
+     * @returns {Promise<Command> | Command}
      */
-    handleCommand(command: Command): Command | Promise<Command>;
+    handleCommand(command: Command): Promise<Command> | Command;
     /**
      * @param {any} response
      * @param {RuntimeName} runtimeName

package/dist/types/core/handler/PassDelegateHandler.d.ts

@@ -68,9 +68,9 @@ export class PassDelegateHandler extends AbstractHandler {
     /**
      * Creates a method call to execute the command.
      * @param {Command} command - The command object.
-     * @returns {any} The response object.
+     * @returns {Promise<any>} The response object.
      */
-    createExecuteCall(command: Command): any;
+    createExecuteCall(command: Command): Promise<any>;
     /**
      * Retrieves the response payload from the execution call.
      * @param {Object<string, any>} executeCall - Object containing the execution call.