javonet-nodejs-sdk 2.1.13 → 2.2.0

package/Binaries/Native/Linux/X64/version.txt

@@ -0,0 +1 @@
+2.2.0

package/Binaries/Native/MacOs/X64/version.txt

@@ -0,0 +1 @@
+2.2.0

package/Binaries/Native/Windows/X64/version.txt

@@ -0,0 +1 @@
+'2.2.0' 

package/Binaries/Nodejs/Linux/X64/core/handler/CreateClassInstanceHandler.js

@@ -1,29 +1,38 @@
 const AbstractHandler = require("./AbstractHandler");
 
 class CreateClassInstanceHandler extends AbstractHandler {
-    requiredParametersCount = 1
+  requiredParametersCount = 1;
 
-    constructor() {
-        super()
-    }
+  constructor() {
+    super();
+  }
 
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Create Class Instance parameters mismatch")
-            }
-            let clazz = command.payload[0]
-            let constructorArguments = command.payload.slice(1)
-            let instance = new clazz(...constructorArguments)
-            if (typeof (instance) == 'undefined') {
-                throw "Instance cannot be created"
-            } else {
-                return instance
-            }
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Create Class Instance parameters mismatch");
+      }
+      let clazz = command.payload[0];
+      let constructorArguments = command.payload.slice(1);
+      let instance = new clazz(...constructorArguments);
+      if (typeof instance === "undefined") {
+        let methods = Object.getOwnPropertyNames(type).filter(function (
+          property
+        ) {
+          return typeof type[property] === "function";
+        });
+        let message = `Method 'constructor' not found in class. Available methods:\n`;
+        methods.forEach((methodIter) => {
+          message += `${methodIter}\n`;
+        });
+        throw new Error(message);
+      } else {
+        return instance;
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
     }
+  }
 }
 
-module.exports = new CreateClassInstanceHandler()
+module.exports = new CreateClassInstanceHandler();

package/Binaries/Nodejs/Linux/X64/core/handler/GetGlobalStaticFieldHandler.js

@@ -1,30 +1,39 @@
-const AbstractHandler = require("./AbstractHandler")
+const AbstractHandler = require("./AbstractHandler");
 
 class GetGlobalStaticFieldHandler extends AbstractHandler {
-    requiredParametersCount = 1
+  requiredParametersCount = 1;
 
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Get global static field parameters mismatch")
-            }
-            const {payload} = command
-            const splitted = payload[0].split(".")
-            let fieldToGet
+  constructor() {
+    super();
+  }
 
-            for (let i = 0; i < splitted.length; i++) {
-                fieldToGet = !fieldToGet ? global[splitted[i]] : fieldToGet[splitted[i]]
-            }
-            return fieldToGet
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Get global static field parameters mismatch");
+      }
+      const { payload } = command;
+      const splitted = payload[0].split(".");
+      let fieldToGet;
 
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
+      for (let i = 0; i < splitted.length; i++) {
+        fieldToGet = !fieldToGet
+          ? global[splitted[i]]
+          : fieldToGet[splitted[i]];
+        if (typeof fieldToGet === "undefined") {
+          let fields = Object.keys(global);
+          let message = `Field ${payload[0]} not found in global. Available fields:\n`;
+          fields.forEach((fieldIter) => {
+            message += `${fieldIter}\n`;
+          });
+          throw new Error(message);
         }
+      }
+      return fieldToGet;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
     }
+  }
 }
 
-module.exports = new GetGlobalStaticFieldHandler()
+module.exports = new GetGlobalStaticFieldHandler();

package/Binaries/Nodejs/Linux/X64/core/handler/GetInstanceFieldHandler.js

@@ -1,30 +1,35 @@
 const AbstractHandler = require("./AbstractHandler");
 
 class GetInstanceFieldHandler extends AbstractHandler {
-    requiredParametersCount = 2
+  requiredParametersCount = 2;
 
-    constructor() {
-        super()
-    }
+  constructor() {
+    super();
+  }
 
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Get Instance Field parameters mismatch")
-            }
-            const {payload} = command
-            let instance = payload[0]
-            let field = payload[1]
-            let instanceField = instance[field]
-            if (typeof (instanceField) === 'undefined') {
-                throw new Error("Instance field does not exist")
-            } else {
-                return instanceField
-            }
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Get Instance Field parameters mismatch");
+      }
+      const { payload } = command;
+      let instance = payload[0];
+      let field = payload[1];
+      let instanceField = instance[field];
+      if (typeof instanceField === "undefined") {
+        let fields = Object.keys(instance);
+        let message = `Field ${field} not found in object. Available fields:\n`;
+        fields.forEach((fieldIter) => {
+          message += `${fieldIter}\n`;
+        });
+        throw new Error(message);
+      } else {
+        return instanceField;
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
     }
+  }
 }
 
-module.exports = new GetInstanceFieldHandler()
+module.exports = new GetInstanceFieldHandler();

package/Binaries/Nodejs/Linux/X64/core/handler/GetStaticFieldHandler.js

@@ -1,32 +1,36 @@
 const AbstractHandler = require("./AbstractHandler");
 
 class GetStaticFieldHandler extends AbstractHandler {
-    requiredParametersCount = 2
+  requiredParametersCount = 2;
 
-    constructor() {
-        super()
-    }
+  constructor() {
+    super();
+  }
 
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Array Static Field parameters mismatch")
-            }
-            const {payload} = command
-            let type = payload[0]
-            let field = payload[1]
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Array Static Field parameters mismatch");
+      }
+      const { payload } = command;
+      let type = payload[0];
+      let field = payload[1];
 
-            let staticField = type[field]
-            if (typeof (staticField) === 'undefined') {
-                throw new Error("Static field does not exist")
-            } else {
-                return staticField
-            }
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
+      let staticField = type[field];
+      if (typeof staticField === "undefined") {
+        let fields = Object.keys(type);
+        let message = `Field ${field} not found in class. Available fields:\n`;
+        fields.forEach((fieldIter) => {
+          message += `${fieldIter}\n`;
+        });
+        throw new Error(message);
+      } else {
+        return staticField;
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
     }
+  }
 }
 
-
-module.exports = new GetStaticFieldHandler()
+module.exports = new GetStaticFieldHandler();

package/Binaries/Nodejs/Linux/X64/core/handler/InvokeGlobalMethodHandler.js

@@ -1,36 +1,47 @@
 const AbstractHandler = require("./AbstractHandler");
 
 class InvokeGlobalMethodHandler extends AbstractHandler {
-    requiredParametersCount = 1
+  requiredParametersCount = 1;
 
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Invoke Global Method parameters mismatch")
-            }
-            const {payload} = command
-            const splitted = payload[0].split(".")
-            let methodToInvoke
-            for (let i = 0; i < splitted.length; i++) {
-                methodToInvoke = !methodToInvoke ? global[splitted[i]] : methodToInvoke[splitted[i]]
-            }
-            if (payload.length > 1) {
-                const args = payload.slice(1)
-                return methodToInvoke(args)
-            } else {
-                return methodToInvoke()
-            }
+  constructor() {
+    super();
+  }
 
-
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Invoke Global Method parameters mismatch");
+      }
+      const { payload } = command;
+      const splitted = payload[0].split(".");
+      let methodToInvoke;
+      for (let i = 0; i < splitted.length; i++) {
+        methodToInvoke = !methodToInvoke
+          ? global[splitted[i]]
+          : methodToInvoke[splitted[i]];
+      }
+      if (typeof methodToInvoke === "undefined") {
+        let methods = Object.getOwnPropertyNames(global).filter(function (
+          property
+        ) {
+          return typeof global[property] === "function";
+        });
+        let message = `Method ${payload[0]} not found in global. Available methods:\n`;
+        methods.forEach((methodIter) => {
+          message += `${methodIter}\n`;
+        });
+        throw new Error(message);
+      }
+      if (payload.length > 1) {
+        const args = payload.slice(1);
+        return methodToInvoke(args);
+      } else {
+        return methodToInvoke();
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
     }
-
+  }
 }
 
-module.exports = new InvokeGlobalMethodHandler()
+module.exports = new InvokeGlobalMethodHandler();

package/Binaries/Nodejs/Linux/X64/core/handler/InvokeInstanceMethodHandler.js

@@ -1,32 +1,40 @@
 const AbstractHandler = require("./AbstractHandler");
 
 class InvokeInstanceMethodHandler extends AbstractHandler {
-    requiredParametersCount = 2
+  requiredParametersCount = 2;
 
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Invoke Instance Method parameters mismatch")
-            }
-            const {payload} = command
-            let instance = payload[0]
-            let methodName = payload[1]
-            let args = payload.slice(2)
-            let method = instance[methodName]
-            if (typeof (method) === 'undefined') {
-                throw new Error("Instance method does not exist")
-            } else {
-                return Reflect.apply(instance[methodName], undefined, args)
-            }
+  constructor() {
+    super();
+  }
 
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Invoke Instance Method parameters mismatch");
+      }
+      const { payload } = command;
+      let instance = payload[0];
+      let methodName = payload[1];
+      let args = payload.slice(2);
+      let method = instance[methodName];
+      if (typeof method === "undefined") {
+        let methods = Object.getOwnPropertyNames(instance.__proto__).filter(
+          function (property) {
+            return typeof instance.__proto__[property] === "function";
+          }
+        );
+        let message = `Method ${methodName} not found in object. Available methods:\n`;
+        methods.forEach((methodIter) => {
+          message += `${methodIter}\n`;
+        });
+        throw new Error(message);
+      } else {
+        return Reflect.apply(method, instance, args);
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
     }
+  }
 }
 
-module.exports = new InvokeInstanceMethodHandler()
+module.exports = new InvokeInstanceMethodHandler();

package/Binaries/Nodejs/Linux/X64/core/handler/InvokeStaticMethodHandler.js

@@ -1,31 +1,40 @@
-const AbstractHandler = require('./AbstractHandler')
+const AbstractHandler = require("./AbstractHandler");
 
 class InvokeStaticMethodHandler extends AbstractHandler {
-    requiredParametersCount = 2
+  requiredParametersCount = 2;
 
-    constructor() {
-        super()
-    }
+  constructor() {
+    super();
+  }
 
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Invoke Static Method parameters mismatch")
-            }
-            const {payload} = command
-            let type = payload[0]
-            let methodName = payload[1]
-            let args = payload.slice(2)
-            let method = type[methodName]
-            if (typeof (method) === 'undefined') {
-                throw new Error("Static method does not exist")
-            } else {
-                return Reflect.apply(method, undefined, args)
-            }
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
-        }
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Invoke Static Method parameters mismatch");
+      }
+      const { payload } = command;
+      let type = payload[0];
+      let methodName = payload[1];
+      let args = payload.slice(2);
+      let method = type[methodName];
+      if (typeof method === "undefined") {
+        let methods = Object.getOwnPropertyNames(type).filter(function (
+          property
+        ) {
+          return typeof type[property] === "function";
+        });
+        let message = `Method ${methodName} not found in class. Available methods:\n`;
+        methods.forEach((methodIter) => {
+          message += `${methodIter}\n`;
+        });
+        throw new Error(message);
+      } else {
+        return Reflect.apply(method, undefined, args);
+      }
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
     }
+  }
 }
 
-module.exports = new InvokeStaticMethodHandler()
+module.exports = new InvokeStaticMethodHandler();

package/Binaries/Nodejs/Linux/X64/core/handler/SetGlobalStaticFieldHandler.js

@@ -1,30 +1,44 @@
-const AbstractHandler = require("./AbstractHandler")
+const AbstractHandler = require("./AbstractHandler");
 
 class SetGlobalStaticFieldHandler extends AbstractHandler {
-    requiredParametersCount = 2
+  requiredParametersCount = 2;
 
-    constructor() {
-        super()
-    }
+  constructor() {
+    super();
+  }
 
-    process(command) {
-        try {
-            if (command.payload.length < this.requiredParametersCount) {
-                throw new Error("Set gloabal static field parameters mismatch")
-            }
-            const {payload} = command
-            const splitted = payload[0].split(".")
-            const value = payload[1]
-            let fieldToSet
+  process(command) {
+    try {
+      if (command.payload.length < this.requiredParametersCount) {
+        throw new Error("Set gloabal static field parameters mismatch");
+      }
+      const { payload } = command;
+      const splitted = payload[0].split(".");
+      const value = payload[1];
+      let fieldToSet;
 
-            for (let i = 0; i < splitted.length; i++) {
-                fieldToSet = !fieldToSet ? global[splitted[i]] : fieldToSet[splitted[i]]
-            }
-            fieldToSet = value
-        } catch (error) {
-            throw this.process_stack_trace(error, this.constructor.name)
+      for (let i = 0; i < splitted.length; i++) {
+        if (
+          typeof (fieldToSet
+            ? fieldToSet[splitted[i]]
+            : global[splitted[i]]) === "undefined"
+        ) {
+          let fields = Object.keys(fieldToSet ? fieldToSet : global);
+          let message = `Field ${splitted[i]} not found in object. Available fields:\n`;
+          fields.forEach((fieldIter) => {
+            message += `${fieldIter}\n`;
+          });
+          throw new Error(message);
         }
+        fieldToSet = !fieldToSet
+          ? global[splitted[i]]
+          : fieldToSet[splitted[i]];
+      }
+      fieldToSet = value;
+    } catch (error) {
+      throw this.process_stack_trace(error, this.constructor.name);
     }
+  }
 }
 
-module.exports = new SetGlobalStaticFieldHandler()
+module.exports = new SetGlobalStaticFieldHandler();