javonet-nodejs-sdk 2.0.5 → 2.1.0

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

@@ -0,0 +1,71 @@
+const CommandType = require("../../utils/CommandType");
+const Command = require("../../utils/Command");
+const Runtime = require("../../utils/RuntimeName");
+const ExceptionType = require("../../utils/ExceptionType");
+
+
+class ExceptionSerializer {
+
+
+    static serializeException(exception, command){
+        let exceptionCommand = new Command(
+            Runtime.Nodejs,
+            CommandType.Exception,
+            []
+        )
+        exceptionCommand = exceptionCommand.addArgToPayload(this.getExceptionCode(exception))
+        exceptionCommand = exceptionCommand.addArgToPayload(command.toString())
+        exceptionCommand = exceptionCommand.addArgToPayload(exception.name)
+        exceptionCommand = exceptionCommand.addArgToPayload(exception.message)
+
+        let stackClasses = []
+        let stackMethods = []
+        let stackLines = []
+        let stackFiles = []
+
+        this.serializeStackTrace(exception, stackClasses, stackMethods, stackLines, stackFiles)
+        exceptionCommand = exceptionCommand.addArgToPayload(stackClasses.join("|"))
+        exceptionCommand = exceptionCommand.addArgToPayload(stackMethods.join("|"))
+        exceptionCommand = exceptionCommand.addArgToPayload(stackLines.join("|"))
+        exceptionCommand = exceptionCommand.addArgToPayload(stackFiles.join("|"))
+
+        return exceptionCommand
+    }
+
+    static getExceptionCode(exception) {
+        switch (exception.name) {
+            case "Error":
+                return ExceptionType.EXCEPTION
+            case "TypeError":
+                return ExceptionType.ILLEGAL_ARGUMENT_EXCEPTION
+            case "RangeError":
+                return ExceptionType.INDEX_OUT_OF_BOUNDS_EXCEPTION
+            default:
+                return exception.name;
+        }
+    }
+
+    static serializeStackTrace(exception, stackClasses, stackMethods, stackLines, stackFiles) {
+        const stackTrace = exception.stack.split('\n').slice(1);
+
+        for (let i = 0; i < stackTrace.length; i++) {
+            const parts = stackTrace[i].trim().match(/at\s(.*)\s\((.*):(\d+):(\d+)\)/);
+            if (parts) {
+                stackClasses.push(parts[1]);
+                stackMethods.push('unknown');
+                stackLines.push(parts[3]);
+                stackFiles.push(parts[2]);
+            } else {
+                const parts = stackTrace[i].trim().match(/at\s(.*):(\d+):(\d+)/);
+                if (parts) {
+                    stackClasses.push('unknown');
+                    stackMethods.push('unknown');
+                    stackLines.push(parts[2]);
+                    stackFiles.push(parts[1]);
+                }
+            }
+        }
+    }
+}
+
+module.exports = ExceptionSerializer

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

@@ -0,0 +1,73 @@
+const ExceptionType = require("../../utils/ExceptionType");
+
+
+class ExceptionThrower {
+
+    static throwException(commandException) {
+        let javonetStackCommand = commandException.payload[1];
+        let exceptionName = commandException.payload[2];
+        let exceptionMessage =  commandException.payload[3];
+
+        let stackTraceClasses = commandException.payload[4];
+        let stackTraceMethods = commandException.payload[5];
+        let stackTraceLines = commandException.payload[6];
+        let stackTraceFiles = commandException.payload[7];
+
+        let exceptionType = commandException.payload[0];
+
+        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
+            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
+            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
+            default:
+                let defaultError = new Error()
+                defaultError.stack = this.serializeStack(stackTraceClasses, stackTraceMethods, stackTraceLines, stackTraceFiles)
+                defaultError.name = exceptionName
+                defaultError.message = exceptionMessage
+                defaultError.path = javonetStackCommand
+                throw defaultError
+        }
+    }
+
+    static serializeStack(stackTraceClasses, stackTraceMethods, stackTraceLines, stackTraceFiles) {
+        let stackTraceClassesArray = stackTraceClasses.split('|')
+        let stackTraceMethodsArray = stackTraceMethods.split('|')
+        let stackTraceLinesArray = stackTraceLines.split('|')
+        let stackTraceFilesArray = stackTraceFiles.split('|')
+
+        const stackFrames = [];
+
+
+        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")
+
+
+    }
+}
+module.exports = ExceptionThrower

package/Binaries/Nodejs/Linux/X64/core/generator/handler/GeneratorHandler.js

@@ -11,7 +11,7 @@ class GeneratorHandler {
         for (let i = 0; i < command.payload.length; i++) {
             let existing_string_builder = new NodejsStringBuilder();
             let payloadItem = command.payload[i]
-            generator_handlers.GENERATOR_HANDLER[command.payload[i].commandId].generate_code(existing_string_builder, command, command.payload[i], generator_handlers)
+            generator_handlers.GENERATOR_HANDLER[command.payload[i].commandType].generate_code(existing_string_builder, command, command.payload[i], generator_handlers)
             this.generate_class_file(existing_string_builder, command.payload[i].payload[0], file_path)
             loadedClassFiles.push(this.generate_class_file(existing_string_builder, payloadItem.payload[0],file_path))
         }

package/Binaries/Nodejs/Linux/X64/core/generator/handler/GetTypeGeneratorHandler.js

@@ -16,7 +16,7 @@ class GetTypeGeneratorHandler extends AbstractGeneratorHandler {
             used_object, handlers)
         existing_string_builder.append(OS.EOL)
         for (let i = 2; i < used_object.payload.length; i++) {
-            handlers.GENERATOR_HANDLER[used_object.payload[i].commandId].generate_code(existing_string_builder, common_command, used_object.payload[i], handlers)
+            handlers.GENERATOR_HANDLER[used_object.payload[i].commandType].generate_code(existing_string_builder, common_command, used_object.payload[i], handlers)
             existing_string_builder.append(OS.EOL)
         }
         existing_string_builder.append("}")

package/Binaries/Nodejs/Linux/X64/core/generator/handler/shared/body/SharedBodyHandler.js

@@ -6,7 +6,7 @@ class SharedBodyHandler extends AbstractGeneratorHandler {
     generate_code(existing_string_builder, common_command, used_object, handlers) {
         existing_string_builder.append("{");
         existing_string_builder.append(os.EOL);
-        handlers.SHARED_BODY_HANDLER[used_object.commandId].generate_code(existing_string_builder, common_command, used_object, handlers)
+        handlers.SHARED_BODY_HANDLER[used_object.commandType].generate_code(existing_string_builder, common_command, used_object, handlers)
         existing_string_builder.append("}");
     }
 }

package/Binaries/Nodejs/Linux/X64/core/generator/handler/shared/body/SharedCreateInstanceBodyHandler.js

@@ -1,14 +1,14 @@
 const AbstractGeneratorHandler = require("../../AbstractGeneratorHandler");
 const CommonGenerator = require("../../../internal/CommonGenerator");
 const StringUtils = require("../../../utils/StringUtils");
-const RuntimeJs = require("../../../../../utils/Runtime");
+const RuntimeName = require("../../../../../utils/RuntimeName");
 const OS = require("os");
 
 class SharedCreateInstanceBodyHandler extends AbstractGeneratorHandler {
 
     generate_code(existing_string_builder, common_command, used_object, handlers) {
         existing_string_builder.append("this.instance = Javonet.inMemory().")
-        existing_string_builder.append(StringUtils.capitalizeFirstLetter(Object.keys(RuntimeJs)[common_command.runtime]))
+        existing_string_builder.append(StringUtils.capitalizeFirstLetter(Object.keys(RuntimeName)[common_command.runtimeName]))
         existing_string_builder.append("().")
         existing_string_builder.append("getType(\"")
         existing_string_builder.append(used_object.payload[0])

package/Binaries/Nodejs/Linux/X64/core/generator/handler/shared/body/SharedGetStaticFieldBodyHandler.js

@@ -1,7 +1,7 @@
 const AbstractGeneratorHandler = require("../../AbstractGeneratorHandler");
 const SharedHandlerType = require("../../../internal/SharedHandlerType");
 const StringUtils = require("../../../utils/StringUtils");
-const RuntimeJs = require("../../../../../utils/Runtime");
+const RuntimeName = require("../../../../../utils/RuntimeName");
 const OS = require("os");
 
 class SharedGetStaticFieldBodyHandler extends AbstractGeneratorHandler {
@@ -11,7 +11,7 @@ class SharedGetStaticFieldBodyHandler extends AbstractGeneratorHandler {
             used_object.payload[1],
             handlers)
         existing_string_builder.append("Javonet.inMemory().")
-        existing_string_builder.append(StringUtils.capitalizeFirstLetter(Object.keys(RuntimeJs)[common_command.runtime]))
+        existing_string_builder.append(StringUtils.capitalizeFirstLetter(Object.keys(RuntimeName)[common_command.runtimeName]))
         existing_string_builder.append("().")
         existing_string_builder.append("getType(\"")
         existing_string_builder.append(used_object.payload[3])

package/Binaries/Nodejs/Linux/X64/core/generator/handler/shared/body/SharedGetTypeBodyHandler.js

@@ -1,13 +1,13 @@
 const AbstractGeneratorHandler = require("../../AbstractGeneratorHandler");
 const StringUtils = require("../../../utils/StringUtils");
-const RuntimeJs = require("../../../../../utils/Runtime");
+const RuntimeName = require("../../../../../utils/RuntimeName");
 const OS = require("os");
 
 class SharedGetTypeBodyHandler extends AbstractGeneratorHandler {
 
     generate_code(existing_string_builder, common_command, used_object, handlers) {
         existing_string_builder.append("return Javonet.inMemory().")
-        existing_string_builder.append(StringUtils.capitalizeFirstLetter(Object.keys(RuntimeJs)[common_command.runtime]))
+        existing_string_builder.append(StringUtils.capitalizeFirstLetter(Object.keys(RuntimeName)[common_command.runtimeName]))
         existing_string_builder.append("().")
         existing_string_builder.append("getType(\"")
         existing_string_builder.append(used_object.payload[0])

package/Binaries/Nodejs/Linux/X64/core/generator/handler/shared/body/SharedInvokeStaticMethodBodyHandler.js

@@ -2,7 +2,7 @@ const AbstractGeneratorHandler = require("../../AbstractGeneratorHandler");
 const StringUtils = require("../../../utils/StringUtils");
 const CommonGenerator = require("../../../internal/CommonGenerator");
 const SharedHandlerType = require("../../../internal/SharedHandlerType");
-const RuntimeJs = require("../../../../../utils/Runtime");
+const RuntimeName = require("../../../../../utils/RuntimeName");
 const OS = require("os");
 
 class SharedInvokeStaticMethodBodyHandler extends AbstractGeneratorHandler {
@@ -12,7 +12,7 @@ class SharedInvokeStaticMethodBodyHandler extends AbstractGeneratorHandler {
             used_object.payload[1],
             handlers)
         existing_string_builder.append("Javonet.inMemory().")
-        existing_string_builder.append(StringUtils.capitalizeFirstLetter(Object.keys(RuntimeJs)[common_command.runtime]))
+        existing_string_builder.append(StringUtils.capitalizeFirstLetter(Object.keys(RuntimeName)[common_command.runtimeName]))
         existing_string_builder.append("().")
         existing_string_builder.append("getType(\"")
         existing_string_builder.append(used_object.payload[3])

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

@@ -21,7 +21,7 @@ class AbstractHandler {
             
             if(cmd.payload[i] instanceof Command) {
                 let inner = cmd.payload[i]
-                cmd.payload[i] = Handler.handlers[inner.commandId].handleCommand(inner)
+                cmd.payload[i] = Handler.handlers[inner.commandType].handleCommand(inner)
             }
         }
     }

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

@@ -0,0 +1,12 @@
+const AbstractHandler =  require("./AbstractHandler")
+
+
+class ArrayGetItemHandler extends AbstractHandler {
+    process(command) {
+        let array = command.payload[0]
+        let indexes = command.payload.slice(1)
+        return array[indexes]
+    }
+}
+
+module.exports = new ArrayGetItemHandler()

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

@@ -0,0 +1,10 @@
+const AbstractHandler =  require("./AbstractHandler")
+
+
+class ArrayGetRankHandler extends AbstractHandler {
+    process(command) {
+        throw new Error("ArrayGetRankHandler not implemented")
+    }
+}
+
+module.exports = new ArrayGetRankHandler()

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

@@ -0,0 +1,11 @@
+const AbstractHandler =  require("./AbstractHandler")
+
+
+class ArrayGetSizeHandler extends AbstractHandler {
+    process(command) {
+        let array = command.payload[0]
+        return array.length
+    }
+}
+
+module.exports = new ArrayGetSizeHandler()

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

@@ -0,0 +1,14 @@
+const AbstractHandler =  require("./AbstractHandler")
+
+
+class ArraySetItemHandler extends AbstractHandler {
+    process(command) {
+        let array = command.payload[0]
+        let value = command.payload[1]
+        let indexes = command.payload.slice(2)
+        array[indexes] = value
+        return 0;
+    }
+}
+
+module.exports = new ArraySetItemHandler()

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

@@ -2,9 +2,13 @@ const AbstractHandler = require("./AbstractHandler");
 
 class CreateClassInstanceHandler extends AbstractHandler {
     process(command) {
-        let clazz = command.payload[0]
-        let methodArguments = command.payload.slice(1)
-        return new clazz(...methodArguments)
+        try {
+            let clazz = command.payload[0]
+            let methodArguments = command.payload.slice(1)
+            return new clazz(...methodArguments)
+        } catch (error) {
+            return error
+        }
     }
 }
 

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

@@ -6,14 +6,19 @@ class GetGlobalStaticFieldHandler extends AbstractHandler {
     }
 
     process(command) {
-        const { payload } = command
-        const splitted = payload[0].split(".")
-        let fieldToGet
+        try {
+            const {payload} = command
+            const splitted = payload[0].split(".")
+            let fieldToGet
 
-        for(let i = 0; i < splitted.length; i++) {
-            fieldToGet = !fieldToGet ? global[splitted[i]] : fieldToGet[splitted[i]]
+            for (let i = 0; i < splitted.length; i++) {
+                fieldToGet = !fieldToGet ? global[splitted[i]] : fieldToGet[splitted[i]]
+            }
+            return fieldToGet
+
+        } catch (error) {
+            return error
         }
-        return fieldToGet
     }
 }
 

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

@@ -6,11 +6,15 @@ class GetInstanceFieldHandler extends AbstractHandler {
     }
 
     process(command) {
-        const { payload } = command
-        let instance = payload[0]
-        let field = payload[1]
+        try {
+            const {payload} = command
+            let instance = payload[0]
+            let field = payload[1]
 
-        return instance[field]
+            return instance[field]
+        } catch (error) {
+            return error
+        }
     }
 }
 

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

@@ -6,11 +6,15 @@ class GetStaticFieldHandler extends AbstractHandler {
     }
 
     process(command) {
-        const { payload } = command
-        let type = payload[0]
-        let field = payload[1]
+        try {
+            const {payload} = command
+            let type = payload[0]
+            let field = payload[1]
 
-        return type[field]
+            return type[field]
+        } catch (error) {
+            return error
+        }
     }
 }
 

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

@@ -6,18 +6,20 @@ class GetTypeHandler extends AbstractHandler {
     }
 
     process(command) {
-        const { payload } = command
-        let typeName = payload[0]
-        typeName = typeName.replace(".js", "")
-        let type = global[typeName]
-        if (type == undefined) {
-            throw `Cannot load ${typeName}`
-        }
-        else { 
-            return type
+        try {
+            const {payload} = command
+            let typeName = payload[0]
+            typeName = typeName.replace(".js", "")
+            let type = global[typeName]
+            if (type == undefined) {
+                throw `Cannot load ${typeName}`
+            } else {
+                return type
+            }
+        } catch (error) {
+            return error
         }
 
-        
     }
 }