javonet-nodejs-sdk 2.0.1 → 2.0.5

package/lib/core/handler/GetInstanceFieldHandler.js

@@ -1,17 +1,17 @@
-const AbstractHandler = require("./AbstractHandler");
-
-class GetInstanceFieldHandler extends AbstractHandler {
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        const { payload } = command
-        let instance = payload[0]
-        let field = payload[1]
-
-        return instance[field]
-    }
-}
-
+const AbstractHandler = require("./AbstractHandler");
+
+class GetInstanceFieldHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        const { payload } = command
+        let instance = payload[0]
+        let field = payload[1]
+
+        return instance[field]
+    }
+}
+
 module.exports = new GetInstanceFieldHandler()

package/lib/core/handler/GetStaticFieldHandler.js

@@ -1,18 +1,18 @@
-const AbstractHandler = require("./AbstractHandler");
-
-class GetStaticFieldHandler extends AbstractHandler {
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        const { payload } = command
-        let type = payload[0]
-        let field = payload[1]
-
-        return type[field]
-    }
-}
-
-
+const AbstractHandler = require("./AbstractHandler");
+
+class GetStaticFieldHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        const { payload } = command
+        let type = payload[0]
+        let field = payload[1]
+
+        return type[field]
+    }
+}
+
+
 module.exports = new GetStaticFieldHandler()

package/lib/core/handler/GetTypeHandler.js

@@ -1,24 +1,24 @@
-const AbstractHandler = require("./AbstractHandler");
-
-class GetTypeHandler extends AbstractHandler {
-    constructor() {
-        super()
-    }
-
-    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
-        }
-
-        
-    }
-}
-
+const AbstractHandler = require("./AbstractHandler");
+
+class GetTypeHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    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
+        }
+
+        
+    }
+}
+
 module.exports = new GetTypeHandler()

package/lib/core/handler/Handler.js

@@ -1,52 +1,58 @@
-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 InvokeInstanceMethodHandler = require('./InvokeInstanceMethodHandler')
-const DestructReference = require("./DestructReferenceHandler");
-const Cast = require('./CastingHandler')
-const InvokeGlobalMethod = require('./InvokeGlobalMethodHandler')
-
-const ReferenceCache = require('./ReferencesCache')
-
-function isResponseSimpleType(obj) {
-    let type = typeof(obj)
-    return ['string', 'boolean', 'number'].includes(type)
-}
-
-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.InvokeInstanceMethod]: InvokeInstanceMethodHandler,
-    [CommandType.InvokeGlobalMethod]: InvokeGlobalMethod,
-    [CommandType.DestructReference]: DestructReference
-}
-
-class Handler {
-    handleCommand(command) {
-        let result = handlers[command.commandId].handleCommand(command)
-        if(isResponseSimpleType(result)) {
-            return command.createResponse(result)
-        } else {
-            let cache = ReferenceCache.getInstance()
-            let uuid = cache.cacheReference(result)
-            return command.createReference(uuid)
-        }
-    }
-}
-
-module.exports.Handler = Handler
-module.exports.handlers = handlers
-
+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 InvokeInstanceMethodHandler = require('./InvokeInstanceMethodHandler')
+const DestructReference = require("./DestructReferenceHandler");
+const Cast = require('./CastingHandler')
+const InvokeGlobalMethod = require('./InvokeGlobalMethodHandler')
+
+const ReferenceCache = require('./ReferencesCache')
+
+function isResponseSimpleType(response) {
+    let type = typeof(response)
+    return ['string', 'boolean', 'number'].includes(type)
+}
+
+function isResponseArray(response) {
+    return response instanceof Array
+}
+
+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.InvokeInstanceMethod]: InvokeInstanceMethodHandler,
+    [CommandType.InvokeGlobalMethod]: InvokeGlobalMethod,
+    [CommandType.DestructReference]: DestructReference
+}
+
+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 cache = ReferenceCache.getInstance()
+            let uuid = cache.cacheReference(result)
+            return command.createReference(uuid)
+        }
+    }
+}
+
+module.exports.Handler = Handler
+module.exports.handlers = handlers
+

package/lib/core/handler/InvokeGlobalMethodHandler.js

@@ -1,22 +1,22 @@
-const AbstractHandler = require("./AbstractHandler");
-
-class InvokeGlobalMethodHandler extends AbstractHandler {
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        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)
-    }
-
-}
-
+const AbstractHandler = require("./AbstractHandler");
+
+class InvokeGlobalMethodHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        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)
+    }
+
+}
+
 module.exports = new InvokeGlobalMethodHandler()

package/lib/core/handler/InvokeInstanceMethodHandler.js

@@ -1,18 +1,18 @@
-const AbstractHandler = require("./AbstractHandler");
-
-class InvokeInstanceMethodHandler extends AbstractHandler {
-    constructor() {
-        super()
-    }
-
-    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)
-    }
-}
-
+const AbstractHandler = require("./AbstractHandler");
+
+class InvokeInstanceMethodHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    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)
+    }
+}
+
 module.exports = new InvokeInstanceMethodHandler()

package/lib/core/handler/InvokeStaticMethodHandler.js

@@ -1,18 +1,18 @@
-const AbstractHandler = require('./AbstractHandler')
-
-class InvokeStaticMethodHandler extends AbstractHandler {
-    constructor() {
-        super()
-    }
-
-    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)
-    }
-}
-
-module.exports = new InvokeStaticMethodHandler()
+const AbstractHandler = require('./AbstractHandler')
+
+class InvokeStaticMethodHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    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)
+    }
+}
+
+module.exports = new InvokeStaticMethodHandler()

package/lib/core/handler/LoadLibraryHandler.js

@@ -1,27 +1,27 @@
-const AbstractHandler = require('./AbstractHandler')
-
-class LoadLibraryHandler extends AbstractHandler {
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        let {payload} = command
-        let [lib] = payload
-        let pathArray = lib.split(/[/\\]/)
-        let libraryName = pathArray.length > 1 ? pathArray[pathArray.length - 1] : pathArray[0]
-        libraryName = libraryName.replace('.js', '')
-        try {
-            global[libraryName] = require(lib)
-        } catch(error) {
-            try {
-                global[libraryName] = require(`${process.cwd()}/${lib}`)
-            } catch {
-                throw `Cannot load ${lib}`
-            }
-        }
-        return 0
-    }
-}
-
-module.exports = new LoadLibraryHandler()
+const AbstractHandler = require('./AbstractHandler')
+
+class LoadLibraryHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        let {payload} = command
+        let [lib] = payload
+        let pathArray = lib.split(/[/\\]/)
+        let libraryName = pathArray.length > 1 ? pathArray[pathArray.length - 1] : pathArray[0]
+        libraryName = libraryName.replace('.js', '')
+        try {
+            global[libraryName] = require(lib)
+        } catch(error) {
+            try {
+                global[libraryName] = require(`${process.cwd()}/${lib}`)
+            } catch {
+                throw `Cannot load ${lib}`
+            }
+        }
+        return 0
+    }
+}
+
+module.exports = new LoadLibraryHandler()

package/lib/core/handler/ReferencesCache.js

@@ -1,30 +1,30 @@
-let _cache = {}
-let _instance = null
-const v4 = require('../../utils/uuid/v4')
-
-class ReferencesCache {
-
-    static getInstance() {
-        if(_instance === null) {
-            _instance = new ReferencesCache()
-        }
-        return _instance
-    }
-
-    cacheReference(reference) {
-        let id = v4()
-        _cache[id] = reference
-        return id
-    }
-
-    resolveReference(id) {
-        return _cache[id]
-    }
-
-    deleteReference(referenceGuid) {
-        delete _cache[referenceGuid]
-        return 0;
-    }
-}
-
+let _cache = {}
+let _instance = null
+const v4 = require('../../utils/uuid/v4')
+
+class ReferencesCache {
+
+    static getInstance() {
+        if(_instance === null) {
+            _instance = new ReferencesCache()
+        }
+        return _instance
+    }
+
+    cacheReference(reference) {
+        let id = v4()
+        _cache[id] = reference
+        return id
+    }
+
+    resolveReference(id) {
+        return _cache[id]
+    }
+
+    deleteReference(referenceGuid) {
+        delete _cache[referenceGuid]
+        return 0;
+    }
+}
+
 module.exports = ReferencesCache

package/lib/core/handler/ResolveReferenceHandler.js

@@ -1,14 +1,14 @@
-const AbstractHandler = require("./AbstractHandler");
-const ReferenceCache = require("./ReferencesCache")
-
-class ResolveReferenceHandler extends AbstractHandler {
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        return ReferenceCache.getInstance().resolveReference(command.payload[0])
-    }
-}
-
+const AbstractHandler = require("./AbstractHandler");
+const ReferenceCache = require("./ReferencesCache")
+
+class ResolveReferenceHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        return ReferenceCache.getInstance().resolveReference(command.payload[0])
+    }
+}
+
 module.exports = new ResolveReferenceHandler()

package/lib/core/handler/SetGlobalStaticFieldHandler.js

@@ -1,21 +1,21 @@
-const AbstractHandler = require("./AbstractHandler")
-
-class SetGlobalStaticFieldHandler extends AbstractHandler {
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        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
-    }
-}
-
+const AbstractHandler = require("./AbstractHandler")
+
+class SetGlobalStaticFieldHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        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
+    }
+}
+
 module.exports = new SetGlobalStaticFieldHandler()

package/lib/core/handler/SetStaticFieldHandler.js

@@ -1,16 +1,16 @@
-const AbstractHandler = require('./AbstractHandler')
-
-class SetStaticFieldHandler extends AbstractHandler {
-    constructor() {
-        super()
-    }
-
-    process(command) {
-        const { payload } = command
-        let [obj, field, value] = payload        
-        obj[field] = value
-        return 0
-    }
-}
-
+const AbstractHandler = require('./AbstractHandler')
+
+class SetStaticFieldHandler extends AbstractHandler {
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        const { payload } = command
+        let [obj, field, value] = payload        
+        obj[field] = value
+        return 0
+    }
+}
+
 module.exports =  new SetStaticFieldHandler()

package/lib/core/interpreter/Interpreter.js

@@ -1,32 +1,32 @@
-const { Handler } = require('../handler/Handler')
-const CommandEncoder = require('../protocol/CommandEncoder')
-const CommandDecoder = require('../protocol/CommandDecoder')
-
-
-let Transmitter
-
-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 bytes = Transmitter.sendCommand(byteMessage)
-        return new CommandDecoder(bytes).decode()
-    }
-
-    process(byteArray) {
-        let decoder = new CommandDecoder(byteArray)
-        let command = decoder.decode()
-
-        return this.handler.handleCommand(command)
-    }
-}
-
-module.exports = Interpreter
+const { Handler } = require('../handler/Handler')
+const CommandEncoder = require('../protocol/CommandEncoder')
+const CommandDecoder = require('../protocol/CommandDecoder')
+
+
+let Transmitter
+
+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 bytes = Transmitter.sendCommand(byteMessage)
+        return new CommandDecoder(bytes).decode()
+    }
+
+    process(byteArray) {
+        let decoder = new CommandDecoder(byteArray)
+        let command = decoder.decode()
+
+        return this.handler.handleCommand(command)
+    }
+}
+
+module.exports = Interpreter