javonet-nodejs-sdk 2.0.4 → 2.1.0

package/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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
         }
 
-        
     }
 }
 

package/lib/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)
         }
     }
 }

package/lib/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 error
         }
-        return methodToInvoke(args)
     }
 
 }

package/lib/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 error
+        }
     }
 }
 

package/lib/core/handler/InvokeStaticMethodHandler.js

@@ -6,12 +6,16 @@ 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 error
+        }
     }
 }
 

package/lib/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()

package/lib/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/NodejsTransmitter')
+            }
+            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)
     }
 }

package/lib/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)
     }
 

package/lib/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)
     }
 

package/lib/sdk/internal/InvocationContext.js

@@ -1,9 +1,7 @@
 const Interpreter = require("../../core/interpreter/Interpreter")
 const Command = require("../../utils/Command")
 const CommandType = require("../../utils/CommandType")
-const Runtime = require("../../utils/Runtime")
-const {Handler} = require("../../core/handler/Handler");
-const CommandEncoder = require('../../core/protocol/CommandEncoder')
+const ExceptionThrower = require("../../core/exception/ExceptionThrower");
 
 class InvocationContext {
     #runtime
@@ -29,7 +27,7 @@ class InvocationContext {
     }
 
     destructor() {
-        if (this.#currentCommand.commandId === CommandType.Reference) {
+        if (this.#currentCommand.commandType === CommandType.Reference) {
             this.#currentCommand = new Command(this.#runtime, CommandType.DestructReference, this.#currentCommand.payload)
             this.execute()
         }
@@ -37,19 +35,13 @@ class InvocationContext {
 
     execute() {
         this.#interpreter = new Interpreter()
+        this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.#connectionType, this.#tcpAddress)
 
-        if (this.#currentCommand.runtime === Runtime.Nodejs) {
-            this.#handler = new Handler()
-            this.#responseCommand = this.#handler.handleCommand(this.#currentCommand)
-        } else {
-            this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.#connectionType, this.#tcpAddress)
-        }
-
-        if (this.#responseCommand.commandId === CommandType.Exception) {
-            throw this.#responseCommand.payload[0]
+        if (this.#responseCommand.commandType === CommandType.Exception) {
+            ExceptionThrower.throwException(this.#responseCommand)
         }
 
-        if (this.#responseCommand.commandId === CommandType.CreateClassInstance) {
+        if (this.#responseCommand.commandType === CommandType.CreateClassInstance) {
             this.#currentCommand = this.#responseCommand
             this.#isExecuted = true
             return this
@@ -88,19 +80,51 @@ class InvocationContext {
         return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
     }
 
+    getIndex(...args) {
+        let localCommand = new Command(this.#runtime, CommandType.ArrayGetItem, args)
+        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
+    }
+
+    getSize(...args) {
+        let localCommand = new Command(this.#runtime, CommandType.ArrayGetSize, args)
+        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
+    }
+
+    getRank(...args) {
+        let localCommand = new Command(this.#runtime, CommandType.ArrayGetRank, args)
+        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
+    }
+
+    setIndex(...args) {
+        let localCommand = new Command(this.#runtime, CommandType.ArraySetItem, args)
+        return new InvocationContext(this.#runtime, this.#connectionType, this.#tcpAddress, this.#buildCommand(localCommand))
+    }
+
     getValue() {
         this.#resultValue = this.#currentCommand.payload[0]
         return this.#resultValue;
     }
 
-    #buildCommand = function(command) {
+    #buildCommand = function (command) {
         for (let i = 0; i < command.payload.length; i++) {
-            if (typeof (command.payload[i]) === 'InvocationContext' || command.payload[i] instanceof InvocationContext) {
-                command.payload[i] = command.payload[i].#currentCommand
+            command.payload[i] = this.#iterate(command.payload[i])
+        }
+        return command.appendArgument(this.#currentCommand);
+    }
+
+    #iterate = function (payloadItem) {
+        if (typeof (payloadItem) === 'InvocationContext' || payloadItem instanceof InvocationContext) {
+            return new Command(this.runtimeName, CommandType.Value, [payloadItem.#currentCommand])
+        } else if (payloadItem instanceof Array) {
+            for (let i = 0; i < payloadItem.length; i++) {
+                payloadItem[i] = this.#iterate(payloadItem)
             }
+            return new Command(this.runtimeName, CommandType.Array, [payloadItem])
+        } else {
+            return new Command(this.runtimeName, CommandType.Value, [payloadItem])
         }
-        return this.#currentCommand == null ? command : command.appendArgument(this.#currentCommand);
     }
 }
 
-module.exports = InvocationContext
+module
+    .exports = InvocationContext