javonet-nodejs-sdk 2.6.7 → 2.6.8

package/dist/core/handler/Handler.cjs

@@ -142,18 +142,13 @@ class Handler {
   }
   /**
    * @param {Command} command
+   * @returns {Promise<Command> | Command}
    */
   handleCommand(command) {
     try {
       if (command.commandType === import_CommandType.CommandType.RetrieveArray) {
         const responseArray = handlers[import_CommandType.CommandType.Reference].handleCommand(command.payload[0]);
-        if (responseArray instanceof Promise) {
-          return responseArray.then((resolvedResponseArray) => {
-            return import_Command.Command.createArrayResponse(resolvedResponseArray, command.runtimeName);
-          });
-        } else {
-          return import_Command.Command.createArrayResponse(responseArray, command.runtimeName);
-        }
+        return import_Command.Command.createArrayResponse(responseArray, command.runtimeName);
       }
       const response = handlers[command.commandType].handleCommand(command);
       return this.parseCommand(response, command.runtimeName);

package/dist/core/handler/LoadLibraryHandler.cjs

@@ -41,8 +41,8 @@ class LoadLibraryHandler extends import_AbstractHandler.AbstractHandler {
     if (command.payload.length < this.requiredParametersCount) {
       throw new Error("Load Library parameters mismatch");
     }
-    let { payload } = command;
-    let [lib] = payload;
+    const { payload } = command;
+    const [lib] = payload;
     if (!lib) {
       throw new Error("Cannot load module: Library path is required but was not provided");
     }
@@ -54,19 +54,25 @@ class LoadLibraryHandler extends import_AbstractHandler.AbstractHandler {
       const { resolve } = requireDynamic("path");
       _resolve = resolve;
     }
-    const absolutePath = _resolve?.(lib);
-    if (!_existsSync?.(lib ?? "") && !_existsSync?.(absolutePath ?? "")) {
+    const absolutePath = _resolve ? _resolve(lib) : lib;
+    const candidatePaths = [lib, absolutePath];
+    const existingPath = candidatePaths.find((p) => _existsSync && _existsSync(p));
+    if (!existingPath) {
       throw new Error(`Cannot load module: Library not found: ${lib}`);
     }
-    let pathArray = lib.split(/[/\\]/);
+    const normalizedPath = _resolve ? _resolve(existingPath) : existingPath;
+    if (LoadLibraryHandler.loadedLibraries.includes(normalizedPath)) {
+      return 0;
+    }
+    const pathArray = normalizedPath.split(/[/\\]/);
     let libraryName = pathArray.length > 1 ? pathArray[pathArray.length - 1] : pathArray[0];
-    libraryName = libraryName.replace(".js", "");
+    libraryName = libraryName.replace(/\.js$/i, "");
     let moduleExports;
     try {
-      moduleExports = requireDynamic(lib);
-      LoadLibraryHandler.loadedLibraries.push(lib);
+      moduleExports = requireDynamic(normalizedPath);
+      LoadLibraryHandler.loadedLibraries.push(normalizedPath);
     } catch (error) {
-      throw Error("Cannot load module: " + lib + "\n" + error);
+      throw new Error("Cannot load module: " + normalizedPath + "\n" + error);
     }
     global[libraryName] = moduleExports;
     for (const [key, value] of Object.entries(moduleExports)) {

package/dist/core/handler/PassDelegateHandler.cjs

@@ -110,9 +110,9 @@ class PassDelegateHandler extends import_AbstractHandler.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) {
+  async createExecuteCall(command) {
     return this.interpreter?.execute(command, new import_InMemoryConnectionData.InMemoryConnectionData());
   }
   /**

package/dist/core/interpreter/Interpreter.cjs

@@ -48,17 +48,19 @@ class Interpreter {
    *
    * @param {Command} command
    * @param {IConnectionData} connectionData
-   * @returns {Command | Promise<Command>}
+   * @returns {Promise<Command>}
    */
-  execute(command, connectionData) {
+  async execute(command, connectionData) {
     try {
       let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
-      if (!(messageByteArray instanceof Uint8Array) && !(messageByteArray instanceof Promise)) {
-        throw new Error("Serialized message is neither Uint8Array nor Promise<Uint8Array>");
+      if (!(messageByteArray instanceof Uint8Array)) {
+        throw new Error("Serialized message is not Uint8Array");
       }
       let responseByteArray = void 0;
       if (!(0, import_Runtime.isNodejsRuntime)() && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
-        throw new Error("Nodejs Core Error: inMemory is only allowed in Nodejs runtime, not in browser");
+        throw new Error(
+          "Nodejs Core Error: inMemory is only allowed in Nodejs runtime, not in browser"
+        );
       }
       if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
         if (!_Receiver) {
@@ -68,13 +70,7 @@ class Interpreter {
         if (!_Receiver) {
           throw new Error("Nodejs Core Error: Receiver is undefined");
         }
-        if (messageByteArray instanceof Promise) {
-          responseByteArray = messageByteArray.then((resolvedMessage) => {
-            return _Receiver.sendCommand(resolvedMessage);
-          });
-        } else if (messageByteArray instanceof Uint8Array) {
-          responseByteArray = _Receiver.sendCommand(messageByteArray);
-        }
+        responseByteArray = await _Receiver.sendCommand(messageByteArray);
       } else if (connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY || connectionData.connectionType === import_ConnectionType.ConnectionType.TCP) {
         if (!_Transmitter) {
           const { Transmitter } = require("../transmitter/Transmitter.cjs");
@@ -83,32 +79,14 @@ class Interpreter {
         if (!_Transmitter) {
           throw new Error("Nodejs Core Error: Transmitter is undefined");
         }
-        if (messageByteArray instanceof Uint8Array) {
-          responseByteArray = _Transmitter.sendCommand(messageByteArray);
-        } else {
-          responseByteArray = messageByteArray.then((resolvedMessage) => {
-            return _Transmitter.sendCommand(resolvedMessage);
-          });
-        }
+        responseByteArray = await _Transmitter.sendCommand(messageByteArray);
       } else if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
-        if (messageByteArray instanceof Uint8Array) {
-          responseByteArray = _TransmitterWebsocket.sendCommand(messageByteArray, connectionData);
-        } else {
-          responseByteArray = messageByteArray.then((resolvedMessage) => {
-            return _TransmitterWebsocket.sendCommand(resolvedMessage, connectionData);
-          });
-        }
+        responseByteArray = await _TransmitterWebsocket.sendCommand(messageByteArray, connectionData);
       }
       if (!responseByteArray) {
         throw new Error("No response received from Transmitter");
       }
-      if (responseByteArray instanceof Promise) {
-        return responseByteArray.then((resolvedResponse) => {
-          return new import_CommandDeserializer.CommandDeserializer(resolvedResponse).deserialize();
-        });
-      } else {
-        return new import_CommandDeserializer.CommandDeserializer(responseByteArray).deserialize();
-      }
+      return new import_CommandDeserializer.CommandDeserializer(responseByteArray).deserialize();
     } catch (error) {
       throw error;
     }

package/dist/core/protocol/CommandSerializer.cjs

@@ -30,21 +30,16 @@ var import_TypesHandler = require("../../utils/TypesHandler.cjs");
 class CommandSerializer {
   /**
    * Serializes the root command with connection data and optional runtime version.
-   * @param {Promise<Command> | Command} rootCommand
+   * @param {Command} rootCommand
    * @param {IConnectionData} connectionData
    * @param {number} runtimeVersion
-   * @returns {Promise<Uint8Array> | Uint8Array}
+   * @returns {Uint8Array}
    */
   serialize(rootCommand, connectionData, runtimeVersion = 0) {
     const buffers = [];
-    if (rootCommand instanceof Promise) {
-      return rootCommand.then((resolvedCommand) => {
-        return this.serialize(resolvedCommand, connectionData, runtimeVersion);
-      });
-    }
     buffers.push(Uint8Array.of(rootCommand.runtimeName, runtimeVersion));
     if (connectionData) {
-      buffers.push(connectionData.serializeConnectionData());
+      buffers.push(Uint8Array.from(connectionData.serializeConnectionData()));
     } else {
       buffers.push(Uint8Array.of(0, 0, 0, 0, 0, 0, 0));
     }

package/dist/core/receiver/Receiver.cjs

@@ -39,11 +39,11 @@ class Receiver {
   }
   /**
    * @param {Uint8Array} messageByteArray
-   * @returns {Promise<Uint8Array> | Uint8Array}
+   * @returns {Promise<Uint8Array>}
    */
-  static sendCommand(messageByteArray) {
+  static async sendCommand(messageByteArray) {
     try {
-      let command = new import_Interpreter.Interpreter().process(messageByteArray);
+      let command = await new import_Interpreter.Interpreter().process(messageByteArray);
       return new import_CommandSerializer.CommandSerializer().serialize(command, this.connectionData);
     } catch (error) {
       const exceptionCommand = import_ExceptionSerializer.ExceptionSerializer.serializeException(
@@ -55,13 +55,13 @@ class Receiver {
   }
   /**
    * @param {Uint8Array} messageByteArray
-   * @returns {Promise<Uint8Array> | Uint8Array}
+   * @returns {Promise<Uint8Array>}
    */
-  static heartBeat(messageByteArray) {
+  static async heartBeat(messageByteArray) {
     let response = new Uint8Array(2);
     response[0] = messageByteArray[11];
     response[1] = messageByteArray[12] - 2;
-    return response;
+    return Promise.resolve(response);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/sdk/Activator.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Activator_exports = {};
+__export(Activator_exports, {
+  Activator: () => Activator
+});
+module.exports = __toCommonJS(Activator_exports);
+class Activator {
+  /**
+   * Create a new instance of a type
+   * @param {Function} Type - The constructor function/class
+   * @param {any[] | any} args - The arguments to pass to the constructor
+   * @returns {any} The new instance
+   */
+  static createInstance(Type, args) {
+    if (args == null) {
+      args = [];
+    }
+    if (!Array.isArray(args)) {
+      args = [args];
+    }
+    return new Type(...args);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Activator
+});

package/dist/sdk/ActivatorDetails.cjs

@@ -22,13 +22,23 @@ __export(ActivatorDetails_exports, {
 });
 module.exports = __toCommonJS(ActivatorDetails_exports);
 class ActivatorDetails {
+  /** @type {Function} */
+  Type;
+  /** @type {any[]} */
+  arguments;
   /**
    * @param {Function} type - The constructor function/class
-   * @param {any[]} [args] - Arguments to pass to constructor
+   * @param {any[]|any} [args] - Arguments to pass to constructor (array or single value)
    */
   constructor(type, args = []) {
-    this.type = type;
-    this.arguments = args;
+    this.Type = type;
+    if (args == null) {
+      this.arguments = [];
+    } else if (Array.isArray(args)) {
+      this.arguments = args;
+    } else {
+      this.arguments = [args];
+    }
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/sdk/ConfigRuntimeFactory.cjs

@@ -105,6 +105,15 @@ class ConfigRuntimeFactory {
   nodejs(configName = "default") {
     return this.#getRuntimeContext(import_RuntimeName.RuntimeName.Nodejs, configName);
   }
+  /** 
+   * Creates RuntimeContext instance to interact with the Php runtime.
+   * @param {string} [configName="default"] - The name of the configuration to use (optional).
+   * @return {RuntimeContext} a RuntimeContext instance for the Php runtime
+   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+   */
+  php(configName = "default") {
+    return this.#getRuntimeContext(import_RuntimeName.RuntimeName.Php, configName);
+  }
   /**
    * Creates RuntimeContext instance to interact with the Python 2.7 runtime.
    * @param {string} [configName="default"] - The name of the configuration to use (optional).

package/dist/sdk/InvocationContext.cjs

@@ -36,7 +36,7 @@ class InvocationContext {
   #connectionData;
   /** @type {Command | null} */
   #currentCommand = null;
-  /** @type {Command | Promise<Command> | null} */
+  /** @type {Command | null} */
   #responseCommand = null;
   /** @type {boolean} */
   #isExecuted = false;
@@ -84,30 +84,21 @@ 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.
@@ -115,37 +106,30 @@ class 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 {Promise<InvocationContext> | InvocationContext} the InvocationContext after executing the command.
+   * @returns {Promise<InvocationContext>} the InvocationContext after executing the command.
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
    * @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);
     }
+    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.
@@ -382,21 +366,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 +391,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 +459,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]);

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]);