javonet-ruby-sdk 2.0.4 → 2.1.1

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/core/handler/Handler.js

@@ -1,18 +1,27 @@
 const CommandType = require('../../utils/CommandType')
-const LoadLibrary = require('./LoadLibraryHandler')
-const GetType = require('./GetTypeHandler')
-const InvokeStaticMethod = require('./InvokeStaticMethodHandler')
-const GetStaticField = require('./GetStaticFieldHandler')
-const SetStaticField = require('./SetStaticFieldHandler')
-const ResolveReference = require('./ResolveReferenceHandler')
-const CreateClassInstance = require('./CreateClassInstanceHandler')
-const GetInstanceField = require('./GetInstanceFieldHandler')
+const ValueHandler = require('./ValueHandler')
+const LoadLibraryHandler = require('./LoadLibraryHandler')
+const GetTypeHandler = require('./GetTypeHandler')
+const InvokeStaticMethodHandler = require('./InvokeStaticMethodHandler')
+const GetStaticFieldHandler = require('./GetStaticFieldHandler')
+const SetStaticFieldHandler = require('./SetStaticFieldHandler')
+const ResolveReferenceHandler = require('./ResolveReferenceHandler')
+const CreateClassInstanceHandler = require('./CreateClassInstanceHandler')
+const GetInstanceFieldHandler = require('./GetInstanceFieldHandler')
 const InvokeInstanceMethodHandler = require('./InvokeInstanceMethodHandler')
-const DestructReference = require("./DestructReferenceHandler");
-const Cast = require('./CastingHandler')
-const InvokeGlobalMethod = require('./InvokeGlobalMethodHandler')
+const DestructReferenceHandler = require("./DestructReferenceHandler");
+const CastHandler = require('./CastingHandler')
+const InvokeGlobalMethodHandler = require('./InvokeGlobalMethodHandler')
+const ArrayGetitemHandler = require('./ArrayGetItemHandler')
+const ArrayGetSizeHandler = require('./ArrayGetSizeHandler')
+const ArrayGetRankHandler = require('./ArrayGetRankHandler')
+const ArraySetItemHandler = require('./ArraySetItemHandler')
+
+
+const ExceptionSerializer = require('../exception/ExceptionSerializer')
 
 const ReferenceCache = require('./ReferencesCache')
+const Command = require("../../utils/Command");
 
 function isResponseSimpleType(response) {
     let type = typeof(response)
@@ -23,32 +32,50 @@ function isResponseArray(response) {
     return response instanceof Array
 }
 
+function isResponseError(response) {
+    return response instanceof Error
+}
+
 const handlers = {
-    [CommandType.LoadLibrary]: LoadLibrary,
-    [CommandType.InvokeStaticMethod]: InvokeStaticMethod,
-    [CommandType.GetType]: GetType,
-    [CommandType.GetStaticField]: GetStaticField,
-    [CommandType.SetStaticField]: SetStaticField,
-    [CommandType.CreateClassInstance]: CreateClassInstance,
-    [CommandType.Reference]: ResolveReference,
-    [CommandType.Cast]: Cast,
-    [CommandType.GetInstanceField]: GetInstanceField,
+    [CommandType.Value]: ValueHandler,
+    [CommandType.LoadLibrary]: LoadLibraryHandler,
+    [CommandType.InvokeStaticMethod]: InvokeStaticMethodHandler,
+    [CommandType.GetType]: GetTypeHandler,
+    [CommandType.GetStaticField]: GetStaticFieldHandler,
+    [CommandType.SetStaticField]: SetStaticFieldHandler,
+    [CommandType.CreateClassInstance]: CreateClassInstanceHandler,
+    [CommandType.Reference]: ResolveReferenceHandler,
+    [CommandType.Cast]: CastHandler,
+    [CommandType.GetInstanceField]: GetInstanceFieldHandler,
     [CommandType.InvokeInstanceMethod]: InvokeInstanceMethodHandler,
-    [CommandType.InvokeGlobalMethod]: InvokeGlobalMethod,
-    [CommandType.DestructReference]: DestructReference
+    [CommandType.InvokeGlobalMethod]: InvokeGlobalMethodHandler,
+    [CommandType.DestructReference]: DestructReferenceHandler,
+    [CommandType.ArrayGetItem]: ArrayGetitemHandler,
+    [CommandType.ArrayGetSize]: ArrayGetSizeHandler,
+    [CommandType.ArrayGetRank]: ArrayGetRankHandler,
+    [CommandType.ArraySetItem]: ArraySetItemHandler
 }
 
 class Handler {
+
     handleCommand(command) {
-        let result = handlers[command.commandId].handleCommand(command)
-        if(isResponseSimpleType(result)) {
-            return command.createResponse(result)
-        } else if (isResponseArray(result)) {
-            return command.createArrayResponse(result)
-        } else {
+            let response = handlers[command.commandType].handleCommand(command)
+            if(isResponseError(response)) {
+                return ExceptionSerializer.serializeException(response, command)
+            }
+            else {
+                return this.parseCommand(response, command.runtimeName)
+            }
+    }
+
+    parseCommand(response, runtimeName) {
+        if(isResponseSimpleType(response)) {
+            return Command.createResponse(response, runtimeName)
+        }
+        else {
             let cache = ReferenceCache.getInstance()
-            let uuid = cache.cacheReference(result)
-            return command.createReference(uuid)
+            let uuid = cache.cacheReference(response)
+            return Command.createReference(uuid, runtimeName)
         }
     }
 }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/core/handler/InvokeGlobalMethodHandler.js

@@ -6,15 +6,19 @@ class InvokeGlobalMethodHandler extends AbstractHandler {
     }
 
     process(command) {
-        const { payload } = command
-        const splitted = payload[0].split(".")
-        const args = payload.slice(1)
-        let methodToInvoke
+        try {
+            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]]
+            for (let i = 0; i < splitted.length; i++) {
+                methodToInvoke = !methodToInvoke ? global[splitted[i]] : methodToInvoke[splitted[i]]
+            }
+            return methodToInvoke(args)
+        } catch (error) {
+            return this.process_stack_trace(error, this.constructor.name)
         }
-        return methodToInvoke(args)
     }
 
 }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/core/handler/InvokeInstanceMethodHandler.js

@@ -6,12 +6,16 @@ class InvokeInstanceMethodHandler extends AbstractHandler {
     }
 
     process(command) {
-        const { payload } = command
-        let instance = payload[0]
-        let methodName = payload[1]
-        let args = payload.slice(2)
-
-        return Reflect.apply(instance[methodName], undefined, args)
+        try {
+            const {payload} = command
+            let instance = payload[0]
+            let methodName = payload[1]
+            let args = payload.slice(2)
+            return Reflect.apply(instance[methodName], undefined, args)
+        }
+        catch (error){
+            return this.process_stack_trace(error, this.constructor.name)
+        }
     }
 }
 

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/core/handler/InvokeStaticMethodHandler.js

@@ -6,12 +6,15 @@ class InvokeStaticMethodHandler extends AbstractHandler {
     }
 
     process(command) {
-        const { payload } = command
-        let type = payload[0]
-        let methodName = payload[1]
-        let args = payload.slice(2)
-        
-        return Reflect.apply(type[methodName], undefined, args)
+        try {
+            const {payload} = command
+            let type = payload[0]
+            let methodName = payload[1]
+            let args = payload.slice(2)
+            return Reflect.apply(type[methodName], undefined, args)
+        } catch (error) {
+            return this.process_stack_trace(error, this.constructor.name)
+        }
     }
 }
 

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/core/handler/LoadLibraryHandler.js

@@ -13,11 +13,11 @@ class LoadLibraryHandler extends AbstractHandler {
         libraryName = libraryName.replace('.js', '')
         try {
             global[libraryName] = require(lib)
-        } catch(error) {
+        } catch (error) {
             try {
                 global[libraryName] = require(`${process.cwd()}/${lib}`)
             } catch {
-                throw `Cannot load ${lib}`
+                return this.process_stack_trace(error, this.constructor.name)
             }
         }
         return 0

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/core/handler/ValueHandler.js

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

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/core/interpreter/Interpreter.js

@@ -1,7 +1,7 @@
 const { Handler } = require('../handler/Handler')
 const CommandEncoder = require('../protocol/CommandEncoder')
 const CommandDecoder = require('../protocol/CommandDecoder')
-
+const Runtime = require("../../utils/RuntimeName");
 
 let Transmitter
 
@@ -9,22 +9,27 @@ class Interpreter {
     handler = new Handler()
 
     execute(command, connectionType, tcpAddress) {
-        // lazy transmitter loading
-        if(!Transmitter) {
-            Transmitter = require('../transmitter/NodejsTransmitter')
-        }
-
-        let encoder = new CommandEncoder()
-        let byteMessage = encoder.encode(command,connectionType, tcpAddress)
+        let commandEncoder = new CommandEncoder()
+        let byteMessage = commandEncoder.encode(command,connectionType, tcpAddress)
+        let responseByteArray
 
-        let bytes = Transmitter.sendCommand(byteMessage)
-        return new CommandDecoder(bytes).decode()
+        if (command.runtimeName === Runtime.Nodejs)
+        {
+            return this.process(byteMessage)
+        }
+        else {
+            // lazy transmitter loading
+            if (!Transmitter) {
+                Transmitter = require('../transmitter/Transmitter')
+            }
+            responseByteArray = Transmitter.sendCommand(byteMessage)
+            return new CommandDecoder(responseByteArray).decode()
+        }
     }
 
     process(byteArray) {
         let decoder = new CommandDecoder(byteArray)
         let command = decoder.decode()
-
         return this.handler.handleCommand(command)
     }
 }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/core/protocol/CommandEncoder.js

@@ -1,18 +1,18 @@
 const Command = require("../../utils/Command")
 const TypeEncoder = require('./TypeEncoder')
 const ConnectionType = require("../../utils/ConnectionType");
-const Runtime = require('../../utils/Runtime')
+const Runtime = require('../../utils/RuntimeName')
 
 class CommandEncoder {
     buffer = new Int8Array(2)
     encodedTcp;
 
-    encode(root, connectionType, tcpConnectionData, runtimeVersion = 0) {
-        let deque = [root]
-        this.buffer[0] = root.runtime
+    encode(command, connectionType, tcpConnectionData, runtimeVersion = 0) {
+        let deque = [command]
+        this.buffer[0] = command.runtimeName
         this.buffer[1] = runtimeVersion
         this.#insertIntoBuffer(this.#encodeTcpConnection(connectionType, tcpConnectionData))
-        this.#insertIntoBuffer(new Int8Array([Runtime.Nodejs, root.commandId]))
+        this.#insertIntoBuffer(new Int8Array([Runtime.Nodejs, command.commandType]))
         return this.#encodeRecursively(deque)
     }
 

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/core/protocol/TypeEncoder.js

@@ -27,7 +27,7 @@ class TypeEncoder {
         buffer.writeInt8(Type.JAVONET_COMMAND, 0)
         buffer.fill(Buffer.from(this.encodeInt32Value(cmd.payload.length)), 1, 5)
         buffer.writeInt8(cmd.runtime, 5)
-        buffer.writeInt8(cmd.commandId, 6)
+        buffer.writeInt8(cmd.commandType, 6)
         return Int8Array.from(buffer)
     }
 

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{MacOs/X64/core/transmitter/NodejsTransmitter.js → Linux/X64/core/transmitter/Transmitter.js}

@@ -1,6 +1,6 @@
-const wrapper = require('./NodejsTransmitterWrapper')
+const wrapper = require('./TransmitterWrapper')
 
-class NodejsTransmitter {
+class Transmitter {
 
    static sendCommand(messageArray) {
         return wrapper.sendCommand(messageArray)
@@ -23,4 +23,4 @@ class NodejsTransmitter {
     }
 }
 
-module.exports = NodejsTransmitter
+module.exports = Transmitter

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/core/transmitter/TransmitterWrapper.js

@@ -0,0 +1,25 @@
+let library;
+
+class TransmitterWrapper {
+    static initialize() {
+        if (process.platform === "win32")
+            library = require(`${require('path').resolve(__dirname, '../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`)
+        else if (process.platform === "darwin")
+            library = require(`${require('path').resolve(__dirname, '../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`)
+        else
+            library = require(`${require('path').resolve(__dirname, '../../../')}/build/Release/JavonetNodejsRuntimeAddon.node`)
+        let binariesRootPath = String(`${require('path').resolve(__dirname, '../../../')}`)
+        return library.initializeTransmitter(binariesRootPath)
+    }
+
+    static activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword) {
+        this.initialize()
+        return library.activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword)
+    }
+
+    static sendCommand(messageArray) {
+        return library.sendCommand(messageArray)
+    }
+}
+
+module.exports = TransmitterWrapper

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/utils/Command.js

@@ -1,58 +1,65 @@
 let CommandType = require('./CommandType')
 
 class Command {
-    constructor(runtime, commandType, payload = []) {
-        this.runtime = runtime
-        this.commandId = commandType
+    constructor(runtimeName, commandType, payload = []) {
+        this.runtimeName = runtimeName
+        this.commandType = commandType
         this.payload = payload
     }
 
-    createResponse(...args) {
+    static createResponse(response, runtimeName) {
         return new Command(
-            this.runtime,
-            CommandType.Response,
-            [...args]
+            runtimeName,
+            CommandType.Value,
+            [response]
         )
     }
 
-    createReference(...args) {
+    static createReference(response, runtimeName) {
         return new Command(
-            this.runtime,
+            runtimeName,
             CommandType.Reference,
-            [...args]
+            [response]
         )
     }
 
-    createArrayResponse(...args) {
+    static createArrayResponse(response, runtimeName) {
         return new Command(
-            this.runtime,
+            runtimeName,
             CommandType.Array,
-            [...args]
+            [response]
         )
     }
 
     dropFirstPayloadArg() {
         return new Command(
-            this.runtime,
-            this.commandId,
+            this.runtimeName,
+            this.commandType,
             this.payload.slice(1)
         )
     }
 
     addArgToPayload(arg) {
         return new Command(
-            this.runtime,
-            this.commandId,
+            this.runtimeName,
+            this.commandType,
             this.payload.concat(arg)
         )
     }
-    
-    appendArgument(arg) {
-        return new Command(
-            this.runtime,
-            this.commandId,
-            [arg].concat(this.payload)
-        )
+
+    appendArgument(current_command) {
+        if (current_command == null) {
+            return new Command(
+                this.runtimeName,
+                this.commandType,
+                this.payload)
+        } else {
+            return new Command(
+                this.runtimeName,
+                this.commandType,
+                [current_command].concat(this.payload)
+            )
+        }
     }
 }
 

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/utils/CommandType.js

@@ -1,5 +1,5 @@
 module.exports = {
-    Response: 0,
+    Value: 0,
     LoadLibrary: 1,
     InvokeStaticMethod: 2,
     GetStaticField: 3,
@@ -17,5 +17,9 @@ module.exports = {
     GenerateLib: 15,
     InvokeGlobalMethod: 16,
     DestructReference: 17,
-    Array: 18
+    Array: 18,
+    ArrayGetItem: 19,
+    ArrayGetSize: 20,
+    ArrayGetRank: 21,
+    ArraySetItem: 22
 }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/Linux/X64/utils/ExceptionType.js

@@ -0,0 +1,10 @@
+module.exports = {
+    EXCEPTION: 0,
+    IO_EXCEPTION: 1,
+    FILE_NOT_FOUND_EXCEPTION: 2,
+    RUNTIME_EXCEPTION: 3,
+    ARITHMETIC_EXCEPTION: 4,
+    ILLEGAL_ARGUMENT_EXCEPTION: 5,
+    INDEX_OUT_OF_BOUNDS_EXCEPTION: 6,
+    NULL_POINTER_EXCEPTION: 7
+}

data/lib/javonet-ruby-sdk/Binaries/Nodejs/MacOs/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

data/lib/javonet-ruby-sdk/Binaries/Nodejs/MacOs/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

data/lib/javonet-ruby-sdk/Binaries/Nodejs/MacOs/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))
         }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/MacOs/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("}")

data/lib/javonet-ruby-sdk/Binaries/Nodejs/MacOs/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("}");
     }
 }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/MacOs/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])