javonet-nodejs-sdk 2.1.7 → 2.1.9

package/Binaries/Nodejs/Linux/X64/core/exception/ExceptionThrower.js

@@ -15,41 +15,27 @@ class ExceptionThrower {
 
         let exceptionType = commandException.payload[0];
 
+        let error
         switch (exceptionType) {
             case ExceptionType.EXCEPTION:
             case ExceptionType.IO_EXCEPTION:
             case ExceptionType.FILE_NOT_FOUND_EXCEPTION:
             case ExceptionType.RUNTIME_EXCEPTION:
             case ExceptionType.ARITHMETIC_EXCEPTION:
-                let error = new Error()
-                error.stack = this.serializeStack(stackTraceClasses, stackTraceMethods, stackTraceLines, stackTraceFiles)
-                error.name = exceptionName
-                error.message = exceptionMessage
-                error.path = javonetStackCommand
-                throw error
+                error = new Error()
             case ExceptionType.ILLEGAL_ARGUMENT_EXCEPTION:
             case ExceptionType.NULL_POINTER_EXCEPTION:
-                let typeError = new TypeError()
-                typeError.stack = this.serializeStack(stackTraceClasses, stackTraceMethods, stackTraceLines, stackTraceFiles)
-                typeError.name = exceptionName
-                typeError.message = exceptionMessage
-                typeError.path = javonetStackCommand
-                throw typeError
+                error = new TypeError()
             case ExceptionType.INDEX_OUT_OF_BOUNDS_EXCEPTION:
-                let rangeError = new RangeError()
-                rangeError.stack = this.serializeStack(stackTraceClasses, stackTraceMethods, stackTraceLines, stackTraceFiles)
-                rangeError.name = exceptionName
-                rangeError.message = exceptionMessage
-                rangeError.path = javonetStackCommand
-                throw rangeError
+                error = new RangeError()
             default:
-                let defaultError = new Error()
-                defaultError.stack = this.serializeStack(stackTraceClasses, stackTraceMethods, stackTraceLines, stackTraceFiles)
-                defaultError.name = exceptionName
-                defaultError.message = exceptionMessage
-                defaultError.path = javonetStackCommand
-                throw defaultError
+                error = new Error()
         }
+        error.stack = this.serializeStack(stackTraceClasses, stackTraceMethods, stackTraceLines, stackTraceFiles)
+        error.name = exceptionName
+        error.message = exceptionMessage
+        //error.path = javonetStackCommand
+        return error
     }
 
     static serializeStack(stackTraceClasses, stackTraceMethods, stackTraceLines, stackTraceFiles) {
@@ -58,16 +44,25 @@ class ExceptionThrower {
         let stackTraceLinesArray = stackTraceLines.split('|')
         let stackTraceFilesArray = stackTraceFiles.split('|')
 
-        const stackFrames = [];
-
+        let stackTrace = "";
 
         for (let i = 0; i < stackTraceClassesArray.length; i++) {
-            const frameString = `    at ${stackTraceClassesArray[i]}.${stackTraceMethodsArray[i]} (${stackTraceFilesArray[i]}:${stackTraceLinesArray[i]})`;
-            stackFrames.push(frameString);
-        }
-        return stackFrames.join("\n")
-
+            if (stackTraceClassesArray[i] != "") {
+                stackTrace += `    at ${stackTraceClassesArray[i]}`;
+            }
+            if (i < stackTraceMethodsArray.length && stackTraceMethodsArray[i] != "") {
+                stackTrace += `.${stackTraceMethodsArray[i]}`
+            }
+            if (i < stackTraceFilesArray.length && stackTraceFilesArray[i] != "") {
+                stackTrace += ` ${stackTraceFilesArray[i]}`
+            }
+            if (i < stackTraceLinesArray.length && stackTraceLinesArray[i] != "") {
+                stackTrace += `:${stackTraceLinesArray[i]}`
+            }
+            stackTrace += "\n"
 
+        }
+        return stackTrace
     }
 }
 module.exports = ExceptionThrower

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

@@ -2,13 +2,22 @@ const AbstractHandler = require("./AbstractHandler")
 
 
 class ArrayGetItemHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    requiredParametersCount = 2
+
     process(command) {
         try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error("Array Get Item parameters mismatch")
+            }
             let array = command.payload[0]
             let indexes = command.payload.slice(1)
             return array[indexes]
         } catch (error) {
-            return this.process_stack_trace(error, this.constructor.name)
+            throw this.process_stack_trace(error, this.constructor.name)
         }
     }
 }

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

@@ -6,7 +6,7 @@ class ArrayGetRankHandler extends AbstractHandler {
         try {
             throw new Error("ArrayGetRankHandler not implemented")
         } catch (error) {
-            return this.process_stack_trace(error, this.constructor.name)
+            throw this.process_stack_trace(error, this.constructor.name)
         }
     }
 }

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

@@ -2,12 +2,21 @@ const AbstractHandler = require("./AbstractHandler")
 
 
 class ArrayGetSizeHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    requiredParametersCount = 1
+
     process(command) {
         try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error("Array Get Size parameters mismatch")
+            }
             let array = command.payload[0]
             return array.length
         } catch (error) {
-            return this.process_stack_trace(error, this.constructor.name)
+            throw this.process_stack_trace(error, this.constructor.name)
         }
     }
 }

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

@@ -2,12 +2,16 @@ const AbstractHandler = require("./AbstractHandler")
 
 
 class ArrayHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
     process(command) {
         try {
             let processedArray = command.payload
             return processedArray
         } catch (error) {
-            return this.process_stack_trace(error, this.constructor.name)
+            throw this.process_stack_trace(error, this.constructor.name)
         }
     }
 }

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

@@ -2,15 +2,25 @@ const AbstractHandler = require("./AbstractHandler")
 
 
 class ArraySetItemHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    requiredParametersCount = 3
+
     process(command) {
         try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error("Array Set Item parameters mismatch")
+            }
+
             let array = command.payload[0]
             let value = command.payload[1]
             let indexes = command.payload.slice(2)
             array[indexes] = value
             return 0;
         } catch (error) {
-            return this.process_stack_trace(error, this.constructor.name)
+            throw this.process_stack_trace(error, this.constructor.name)
         }
     }
 }

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

@@ -1,13 +1,27 @@
 const AbstractHandler = require("./AbstractHandler");
 
 class CreateClassInstanceHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    requiredParametersCount = 1
+
     process(command) {
         try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error("Create Class Instance parameters mismatch")
+            }
             let clazz = command.payload[0]
-            let methodArguments = command.payload.slice(1)
-            return new clazz(...methodArguments)
+            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) {
-            return this.process_stack_trace(error, this.constructor.name)
+            throw this.process_stack_trace(error, this.constructor.name)
         }
     }
 }

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

@@ -12,7 +12,7 @@ class DestructReferenceHandler extends AbstractHandler {
             let cache = ReferencesCache.getInstance()
             return cache.deleteReference(command.payload[0])
         } catch (error) {
-            return this.process_stack_trace(error, this.constructor.name)
+            throw this.process_stack_trace(error, this.constructor.name)
         }
     }
 }

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

@@ -5,8 +5,13 @@ class GetGlobalStaticFieldHandler extends AbstractHandler {
         super()
     }
 
+    requiredParametersCount = 1
+
     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
@@ -17,7 +22,7 @@ class GetGlobalStaticFieldHandler extends AbstractHandler {
             return fieldToGet
 
         } catch (error) {
-            return this.process_stack_trace(error, this.constructor.name)
+            throw this.process_stack_trace(error, this.constructor.name)
         }
     }
 }

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

@@ -5,15 +5,25 @@ class GetInstanceFieldHandler extends AbstractHandler {
         super()
     }
 
+    requiredParametersCount = 2
+
     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]
-
-            return instance[field]
+            let instanceField = instance[field]
+            if (typeof(instanceField) === 'undefined') {
+                throw new Error("Instance field does not exist")
+            }
+            else {
+                return instanceField
+            }
         } catch (error) {
-            return this.process_stack_trace(error, this.constructor.name)
+            throw this.process_stack_trace(error, this.constructor.name)
         }
     }
 }

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

@@ -5,15 +5,26 @@ class GetStaticFieldHandler extends AbstractHandler {
         super()
     }
 
+    requiredParametersCount = 2
+
     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]
 
-            return type[field]
+            let staticField = type[field]
+            if (typeof(staticField) === 'undefined') {
+                throw new Error("Static field does not exist")
+            }
+            else {
+                return staticField
+            }
         } catch (error) {
-            return this.process_stack_trace(error, this.constructor.name)
+            throw this.process_stack_trace(error, this.constructor.name)
         }
     }
 }

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

@@ -5,19 +5,24 @@ class GetTypeHandler extends AbstractHandler {
         super()
     }
 
+    requiredParametersCount = 1
+
     process(command) {
         try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error("Get Type parameters mismatch")
+            }
             const {payload} = command
             let typeName = payload[0]
             typeName = typeName.replace(".js", "")
             let type = global[typeName]
             if (type == undefined) {
-                throw `Cannot load ${typeName}`
+                throw new Error(`Cannot load ${typeName}`)
             } else {
                 return type
             }
         } catch (error) {
-            return this.process_stack_trace(error, this.constructor.name)
+            throw this.process_stack_trace(error, this.constructor.name)
         }
 
     }

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

@@ -26,7 +26,7 @@ const ReferenceCache = require('./ReferencesCache')
 const Command = require("../../utils/Command");
 
 function isResponseSimpleType(response) {
-    let type = typeof(response)
+    let type = typeof (response)
     return ['string', 'boolean', 'number'].includes(type)
 }
 
@@ -58,24 +58,22 @@ const handlers = {
 
 class Handler {
     handleCommand(command) {
+        try {
             if (command.commandType == CommandType.RetrieveArray) {
                 let responseArray = handlers[CommandType.Reference].handleCommand(command.payload[0])
                 return Command.createArrayResponse(responseArray, command.runtimeName)
             }
             let response = handlers[command.commandType].handleCommand(command)
-            if(isResponseError(response)) {
-                return ExceptionSerializer.serializeException(response, command)
-            }
-            else {
-                return this.parseCommand(response, command.runtimeName)
-            }
+            return this.parseCommand(response, command.runtimeName)
+        } catch (error) {
+            return ExceptionSerializer.serializeException(error, command)
+        }
     }
 
     parseCommand(response, runtimeName) {
-        if(isResponseSimpleType(response)) {
+        if (isResponseSimpleType(response)) {
             return Command.createResponse(response, runtimeName)
-        }
-        else {
+        } else {
             let cache = ReferenceCache.getInstance()
             let uuid = cache.cacheReference(response)
             return Command.createReference(uuid, runtimeName)

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

@@ -5,19 +5,31 @@ class InvokeGlobalMethodHandler extends AbstractHandler {
         super()
     }
 
+    requiredParametersCount = 1
+
     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(".")
-            const args = payload.slice(1)
             let methodToInvoke
-
             for (let i = 0; i < splitted.length; i++) {
                 methodToInvoke = !methodToInvoke ? global[splitted[i]] : methodToInvoke[splitted[i]]
             }
-            return methodToInvoke(args)
+            if(payload.length > 1) {
+                const args = payload.slice(1)
+                return methodToInvoke(args)
+            } else {
+                return methodToInvoke()
+            }
+
+
+
+
         } catch (error) {
-            return this.process_stack_trace(error, this.constructor.name)
+            throw this.process_stack_trace(error, this.constructor.name)
         }
     }
 

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

@@ -5,16 +5,27 @@ class InvokeInstanceMethodHandler extends AbstractHandler {
         super()
     }
 
+    requiredParametersCount = 2
+
     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)
-            return Reflect.apply(instance[methodName], undefined, args)
+            let method = instance[methodName]
+            if (typeof(method) === 'undefined') {
+                throw new Error("Instance method does not exist")
+            } else {
+                return Reflect.apply(instance[methodName], undefined, args)
+            }
+
         }
         catch (error){
-            return this.process_stack_trace(error, this.constructor.name)
+            throw this.process_stack_trace(error, this.constructor.name)
         }
     }
 }

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

@@ -5,15 +5,25 @@ class InvokeStaticMethodHandler extends AbstractHandler {
         super()
     }
 
+    requiredParametersCount = 2
+
     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)
-            return Reflect.apply(type[methodName], undefined, args)
+            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) {
-            return this.process_stack_trace(error, this.constructor.name)
+            throw this.process_stack_trace(error, this.constructor.name)
         }
     }
 }

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

@@ -5,7 +5,12 @@ class LoadLibraryHandler extends AbstractHandler {
         super()
     }
 
+    requiredParametersCount = 1
+
     process(command) {
+        if (command.payload.length < this.requiredParametersCount) {
+            throw new Error("Load Library parameters mismatch")
+        }
         let {payload} = command
         let [lib] = payload
         let pathArray = lib.split(/[/\\]/)
@@ -16,8 +21,8 @@ class LoadLibraryHandler extends AbstractHandler {
         } catch (error) {
             try {
                 global[libraryName] = require(`${process.cwd()}/${lib}`)
-            } catch {
-                return this.process_stack_trace(error, this.constructor.name)
+            } catch (error) {
+                throw this.process_stack_trace(error, this.constructor.name)
             }
         }
         return 0