javonet-nodejs-sdk 2.6.13 → 2.6.14

package/dist/core/handler/ArraySetItemHandler.cjs

@@ -35,23 +35,24 @@ class ArraySetItemHandler extends import_AbstractHandler.AbstractHandler {
       if (command.payload.length < this.requiredParametersCount) {
         throw new Error("Array Set Item parameters mismatch");
       }
-      let array = command.payload[0];
+      let data = command.payload[0];
+      let indexes_from_payload = command.payload[1];
       let value = command.payload[2];
       let indexes;
-      if (Array.isArray(command.payload[1])) {
-        indexes = command.payload[1];
+      if (Array.isArray(indexes_from_payload)) {
+        indexes = indexes_from_payload;
       } else {
-        indexes = [command.payload[1]];
+        indexes = [indexes_from_payload];
       }
       if (indexes.length === 1) {
-        array[indexes[0]] = value;
+        data[indexes[0]] = value;
       } else {
         for (let i = 0; i < indexes.length - 1; i++) {
-          array = array[indexes[i]];
+          data = data[indexes[i]];
         }
-        array[indexes[indexes.length - 1]] = value;
+        data[indexes[indexes.length - 1]] = value;
       }
-      return 0;
+      return data;
     } catch (error) {
       throw this.process_stack_trace(error, this.constructor.name);
     }

package/dist/core/handler/AsDtoHandler.cjs

@@ -0,0 +1,36 @@
+"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 AsDtoHandler_exports = {};
+__export(AsDtoHandler_exports, {
+  AsDtoHandler: () => AsDtoHandler
+});
+module.exports = __toCommonJS(AsDtoHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class AsDtoHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  process(command) {
+    throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AsDtoHandler
+});

package/dist/core/handler/AsKwargsHandler.cjs

@@ -26,7 +26,7 @@ class AsKwargsHandler extends import_AbstractHandler.AbstractHandler {
   /**
    * @param {any} command
    */
-  handleCommand(command) {
+  process(command) {
     throw new Error(`${this.constructor.name} is not implemented in Node.js`);
   }
 }

package/dist/core/handler/DtoPropertyHandler.cjs

@@ -0,0 +1,36 @@
+"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 DtoPropertyHandler_exports = {};
+__export(DtoPropertyHandler_exports, {
+  DtoPropertyHandler: () => DtoPropertyHandler
+});
+module.exports = __toCommonJS(DtoPropertyHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class DtoPropertyHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  process(command) {
+    throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DtoPropertyHandler
+});

package/dist/core/handler/Handler.cjs

@@ -78,6 +78,9 @@ var import_GetResultTypeHandler = require("./GetResultTypeHandler.cjs");
 var import_GetGlobalFieldHandler = require("./GetGlobalFieldHandler.cjs");
 var import_RegisterForUpdateHandler = require("./RegisterForUpdateHandler.cjs");
 var import_ValueForUpdateHandler = require("./ValueForUpdateHandler.cjs");
+var import_AsDtoHandler = require("./AsDtoHandler.cjs");
+var import_DtoPropertyHandler = require("./DtoPropertyHandler.cjs");
+var import_ProjectResultAsDtoHandler = require("./ProjectResultAsDtoHandler.cjs");
 const handlers = {
   [import_CommandType.CommandType.Value]: new import_ValueHandler.ValueHandler(),
   [import_CommandType.CommandType.LoadLibrary]: new import_LoadLibraryHandler.LoadLibraryHandler(),
@@ -128,7 +131,10 @@ const handlers = {
   [import_CommandType.CommandType.GetResultType]: new import_GetResultTypeHandler.GetResultTypeHandler(),
   [import_CommandType.CommandType.GetGlobalField]: new import_GetGlobalFieldHandler.GetGlobalFieldHandler(),
   [import_CommandType.CommandType.RegisterForUpdate]: new import_RegisterForUpdateHandler.RegisterForUpdateHandler(),
-  [import_CommandType.CommandType.ValueForUpdate]: new import_ValueForUpdateHandler.ValueForUpdateHandler()
+  [import_CommandType.CommandType.ValueForUpdate]: new import_ValueForUpdateHandler.ValueForUpdateHandler(),
+  [import_CommandType.CommandType.AsDto]: new import_AsDtoHandler.AsDtoHandler(),
+  [import_CommandType.CommandType.DtoProperty]: new import_DtoPropertyHandler.DtoPropertyHandler(),
+  [import_CommandType.CommandType.ProjectResultAsDto]: new import_ProjectResultAsDtoHandler.ProjectResultAsDtoHandler()
 };
 class Handler {
   static _initialized = false;
@@ -157,6 +163,9 @@ class Handler {
         return import_Command.Command.createArrayResponse(responseArray, command.runtimeName);
       }
       const response = handlers[command.commandType].handleCommand(command);
+      if (command.commandType === import_CommandType.CommandType.ProjectResultAsDto) {
+        return import_Command.Command.createArrayResponse(response, command.runtimeName);
+      }
       return Handler.parseCommand(response, command.runtimeName);
     } catch (e) {
       return Handler.resolveException(e, command);
@@ -196,14 +205,10 @@ class Handler {
       const refCache = import_ReferencesCache.ReferencesCache.getInstance();
       for (const [contextKey, instance] of invocationContexts.entries()) {
         const instanceGuid = refCache.cacheReference(instance);
-        const updateContextCommand = new import_Command.Command(
-          runtimeName,
-          import_CommandType.CommandType.ValueForUpdate,
-          [
-            contextKey.toString(),
-            instanceGuid
-          ]
-        );
+        const updateContextCommand = new import_Command.Command(runtimeName, import_CommandType.CommandType.ValueForUpdate, [
+          contextKey.toString(),
+          instanceGuid
+        ]);
         if (typeof responseCommand.addArgToPayload === "function") {
           responseCommand = responseCommand.addArgToPayload(updateContextCommand);
         } else {

package/dist/core/handler/PassDelegateHandler.cjs

@@ -121,7 +121,7 @@ class PassDelegateHandler extends import_AbstractHandler.AbstractHandler {
    */
   async createExecuteCall(command) {
     const { Interpreter } = await import("../interpreter/Interpreter.js");
-    return Interpreter.execute(command, new import_InMemoryConnectionData.InMemoryConnectionData());
+    return Interpreter.execute("runtimeContextId", command, new import_InMemoryConnectionData.InMemoryConnectionData());
   }
   /**
    * Retrieves the response payload from the execution call.

package/dist/core/handler/ProjectResultAsDtoHandler.cjs

@@ -0,0 +1,66 @@
+"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 ProjectResultAsDtoHandler_exports = {};
+__export(ProjectResultAsDtoHandler_exports, {
+  ProjectResultAsDtoHandler: () => ProjectResultAsDtoHandler
+});
+module.exports = __toCommonJS(ProjectResultAsDtoHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+var import_GetInstanceFieldHandler = require("./GetInstanceFieldHandler.cjs");
+var import_Command = require("../../utils/Command.cjs");
+var import_CommandType = require("../../utils/CommandType.cjs");
+class ProjectResultAsDtoHandler extends import_AbstractHandler.AbstractHandler {
+  constructor() {
+    super();
+    this.requiredParametersCount = 1;
+  }
+  /**
+   * @param {Command} command
+   */
+  process(command) {
+    if (command.payload.length < this.requiredParametersCount) {
+      throw new Error(`${this.constructor.name} parameters mismatch`);
+    }
+    const instance = command.payload[0];
+    const responseArray = new Array(command.payload.length + 1);
+    responseArray[0] = instance;
+    let typeName = "Object";
+    if (instance !== null && instance !== void 0) {
+      typeName = instance.constructor ? instance.constructor.name : "Object";
+    }
+    responseArray[1] = new import_Command.Command(command.runtimeName, import_CommandType.CommandType.GetType, [typeName]);
+    const getInstanceFieldHandler = new import_GetInstanceFieldHandler.GetInstanceFieldHandler();
+    for (let i = 1; i < command.payload.length; i++) {
+      const propertyName = command.payload[i];
+      const propertyValue = getInstanceFieldHandler.process(
+        new import_Command.Command(command.runtimeName, import_CommandType.CommandType.GetInstanceField, [instance, propertyName])
+      );
+      responseArray[i + 1] = new import_Command.Command(
+        command.runtimeName,
+        import_CommandType.CommandType.DtoProperty,
+        [propertyName, propertyValue]
+      );
+    }
+    return responseArray;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProjectResultAsDtoHandler
+});

package/dist/core/handler/SetInstanceFieldHandler.cjs

@@ -50,7 +50,7 @@ class SetInstanceFieldHandler extends import_AbstractHandler.AbstractHandler {
         throw new Error(message);
       }
       instance[field] = value;
-      return 0;
+      return instance;
     } catch (error) {
       throw this.process_stack_trace(error, this.constructor.name);
     }

package/dist/core/handler/SetStaticFieldHandler.cjs

@@ -36,10 +36,10 @@ class SetStaticFieldHandler extends import_AbstractHandler.AbstractHandler {
         throw new Error("Set static field parameters mismatch");
       }
       const { payload } = command;
-      let [obj, field, value] = payload;
-      if (typeof obj[field] === "undefined") {
-        let fields = Object.keys(obj);
-        let message = `Field ${field} not found in class ${obj.constructor.name}. Available fields:
+      let [type, field, value] = payload;
+      if (typeof type[field] === "undefined") {
+        let fields = Object.keys(type);
+        let message = `Field ${field} not found in class ${type.constructor.name}. Available fields:
 `;
         fields.forEach((fieldIter) => {
           message += `${fieldIter}
@@ -47,8 +47,8 @@ class SetStaticFieldHandler extends import_AbstractHandler.AbstractHandler {
         });
         throw new Error(message);
       }
-      obj[field] = value;
-      return 0;
+      type[field] = value;
+      return type;
     } catch (error) {
       throw this.process_stack_trace(error, this.constructor.name);
     }

package/dist/core/interpreter/Interpreter.cjs

@@ -29,6 +29,10 @@ var import_CommandSerializer = require("../protocol/CommandSerializer.cjs");
 var import_TransmitterWebsocketBrowser = require("../transmitter/TransmitterWebsocketBrowser.cjs");
 var import_TransmitterWebsocket = require("../transmitter/TransmitterWebsocket.cjs");
 var import_Handler = require("../handler/Handler.cjs");
+var import_PluginRegistry = require("../../plugins/PluginRegistry.cjs");
+var import_PluginPayloadBuilder = require("../../plugins/PluginPayloadBuilder.cjs");
+var import_Command = require("../../utils/Command.cjs");
+var import_CommandType = require("../../utils/CommandType.cjs");
 const import_meta = {};
 let _Receiver;
 let _Transmitter;
@@ -36,13 +40,21 @@ let _TransmitterWebsocket = (0, import_Runtime.isNodejsRuntime)() ? import_Trans
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class Interpreter {
   /**
-   *
+   * @param {string} runtimeContextId    
    * @param {Command} command
    * @param {IConnectionData} connectionData
    * @returns {Promise<Command>}
    */
-  static async execute(command, connectionData) {
+  static async execute(runtimeContextId, command, connectionData) {
     try {
+      if (import_PluginRegistry.PluginRegistry.arePluginsRegisteredForRuntime(runtimeContextId)) {
+        const serializedPlugins = import_PluginPayloadBuilder.PluginPayloadBuilder.buildPluginsPayload(runtimeContextId);
+        command = new import_Command.Command(
+          command.runtimeName,
+          import_CommandType.CommandType.PluginWrapper,
+          [serializedPlugins, command]
+        );
+      }
       let messageByteArray = import_CommandSerializer.CommandSerializer.serialize(command, connectionData);
       if (!(messageByteArray instanceof Uint8Array)) {
         throw new Error("Serialized message is not Uint8Array");

package/dist/core/protocol/CommandDeserializer.cjs

@@ -78,6 +78,8 @@ class CommandDeserializer {
         return this.readUInt();
       case "JAVONET_NULL":
         return this.readNull();
+      case "JAVONET_UNDEFINED":
+        return this.readUndefined();
       default:
         throw "Unknown type - not supported in JavaScript";
     }
@@ -189,6 +191,12 @@ class CommandDeserializer {
     this.position += size;
     return import_TypeDeserializer.TypeDeserializer.deserializeNull();
   }
+  readUndefined() {
+    const size = 1;
+    this.position += 2;
+    this.position += size;
+    return import_TypeDeserializer.TypeDeserializer.deserializeUndefined();
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/core/protocol/TypeDeserializer.cjs

@@ -119,6 +119,10 @@ class TypeDeserializer {
   static deserializeNull(encodedNull = null) {
     return null;
   }
+  // eslint-disable-next-line no-unused-vars
+  static deserializeUndefined(encodedUndefined = null) {
+    return void 0;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/core/protocol/TypeSerializer.cjs

@@ -35,6 +35,9 @@ class TypeSerializer {
     if (payload_item === null) {
       return TypeSerializer.serializeNull();
     }
+    if (payload_item === void 0) {
+      return TypeSerializer.serializeUndefined();
+    }
     if (payload_item instanceof import_Command.Command) {
       return TypeSerializer.serializeCommand(payload_item);
     } else if (typeof payload_item === "number") {
@@ -52,11 +55,6 @@ class TypeSerializer {
         const message = "Unsupported payload item type: " + (payload_item?.constructor?.name || typeof payload_item) + " for payload item: " + payload_item;
         throw new import_CustomError.CustomError(message, "JAVONET_PROMISE");
       }
-      if (payload_item === void 0) {
-        throw Error(
-          "Unsupported payload item type: " + typeof payload_item + " for payload item: " + payload_item
-        );
-      }
       throw Error(
         "Unsupported payload item type: " + (payload_item?.constructor?.name || typeof payload_item) + " for payload item: " + payload_item
       );
@@ -182,6 +180,13 @@ class TypeSerializer {
     buffer.writeUInt8(0, 2);
     return buffer;
   }
+  static serializeUndefined() {
+    const buffer = import_buffer.Buffer.alloc(3);
+    buffer.writeUInt8(import_Type.Type.JAVONET_UNDEFINED, 0);
+    buffer.writeUInt8(1, 1);
+    buffer.writeUInt8(0, 2);
+    return buffer;
+  }
   /**
    * @param {number} int_value
    */

package/dist/core/webSocketClient/WebSocketClient.cjs

@@ -151,7 +151,9 @@ class WebSocketClient {
     }
     if (messageQueue[this.url]) {
       messageQueue[this.url].forEach(({ reject }) => {
-        reject(new Error("WebSocket disconnected"));
+        reject(new Error(
+          `WebSocket to ${this.url} was disconnected. The connection was closed before the operation completed.`
+        ));
       });
       delete messageQueue[this.url];
     }
@@ -172,24 +174,40 @@ class WebSocketClient {
           /** @type {{ code?: string }} */
           error.code === "MODULE_NOT_FOUND"
         ) {
-          throw new Error("ws module not found. Please install it using npm install ws");
+          throw new Error(
+            'WebSocket connection failed: the "ws" package is not installed. Install it with: npm install ws'
+          );
         }
         throw error;
       }
     }
     return new Promise((resolve, reject) => {
       if (!WebSocket) {
-        return reject(new Error("ws client is null"));
+        return reject(new Error(
+          'WebSocket connection failed: ws client is not available. In Node.js ensure the "ws" package is installed (npm install ws).'
+        ));
       }
       let client = clients[this.url];
       if (!client) {
         client = new WebSocket(this.url);
         clients[this.url] = client;
       }
+      const wrapReject = (err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        const wrapped = new Error(
+          `WebSocket connection to ${this.url} failed: ${msg}. Check that the server is running, the URL is correct (ws:// or wss://), and that no firewall or proxy is blocking the connection.`
+        );
+        if (err instanceof Error && "cause" in Error.prototype) {
+          wrapped.cause = err;
+        }
+        reject(wrapped);
+      };
       client.on(WebSocketStateEvent.OPEN, () => resolve(client));
-      client.on(WebSocketStateEvent.ERROR, (error) => reject(error));
+      client.on(WebSocketStateEvent.ERROR, (error) => wrapReject(error));
       client.on(WebSocketStateEvent.CLOSE, () => {
-        reject(new Error("Connection closed before receiving message"));
+        reject(new Error(
+          `WebSocket connection to ${this.url} was closed before it could be established. The server may have refused the connection, closed immediately, or a network error occurred. Check that the server is running and the URL is correct.`
+        ));
       });
     });
   }

package/dist/core/webSocketClient/WebSocketClientBrowser.cjs

@@ -128,7 +128,9 @@ class WebSocketClientBrowser {
     }
     if (messageQueue[this.url]) {
       messageQueue[this.url].forEach(({ reject }) => {
-        reject(new Error("WebSocket disconnected"));
+        reject(new Error(
+          `WebSocket to ${this.url} was disconnected. The connection was closed before the operation completed.`
+        ));
       });
       delete messageQueue[this.url];
     }
@@ -143,7 +145,9 @@ class WebSocketClientBrowser {
   _connect() {
     return new Promise((resolve, reject) => {
       if (!WsClient) {
-        return reject(new Error("missing WebSocket client"));
+        return reject(new Error(
+          `WebSocket connection to ${this.url} failed: WebSocket API is not available in this environment. Ensure the code runs in a browser or environment that supports WebSocket.`
+        ));
       }
       let client = clients[this.url];
       if (!client) {
@@ -151,10 +155,22 @@ class WebSocketClientBrowser {
         client.binaryType = "arraybuffer";
         clients[this.url] = client;
       }
+      const wrapReject = (err) => {
+        const msg = err instanceof Error ? err.message : err instanceof Event && err.type ? `Event: ${err.type}` : String(err);
+        const wrapped = new Error(
+          `WebSocket connection to ${this.url} failed: ${msg}. Check that the server is running, the URL is correct (ws:// or wss://), and that no firewall, CORS, or proxy is blocking the connection.`
+        );
+        if (err instanceof Error && "cause" in Error.prototype) {
+          wrapped.cause = err;
+        }
+        reject(wrapped);
+      };
       client.addEventListener(WebSocketState.OPEN, () => resolve(client));
-      client.addEventListener(WebSocketState.ERROR, reject);
+      client.addEventListener(WebSocketState.ERROR, (e) => wrapReject(e));
       client.addEventListener(WebSocketState.CLOSE, () => {
-        reject(new Error("Connection closed before receiving message"));
+        reject(new Error(
+          `WebSocket connection to ${this.url} was closed before it could be established. The server may have refused the connection or a network error occurred. Check that the server is running and the URL is correct.`
+        ));
       });
     });
   }
@@ -172,7 +188,9 @@ class WebSocketClientBrowser {
       client.send(arrayBuffer);
       const handleMessage = (message) => {
         if (!message?.data) {
-          return reject(new Error("Invalid message received"));
+          return reject(new Error(
+            `WebSocket to ${this.url}: invalid message received (no data). The server response may be malformed.`
+          ));
         }
         const byteArray = new Uint8Array(message?.data);
         resolve(byteArray);