javonet-ruby-sdk 2.5.7 → 2.5.9

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/handler/Handler.js

@@ -1,8 +1,3 @@
-const CommandType = require('../../utils/CommandType')
-const Command = require("../../utils/Command");
-const ReferenceCache = require('../referenceCache/ReferencesCache')
-const ExceptionSerializer = require('../../utils/exception/ExceptionSerializer')
-
 const ValueHandler = require('./ValueHandler')
 const LoadLibraryHandler = require('./LoadLibraryHandler')
 const GetTypeHandler = require('./GetTypeHandler')
@@ -14,7 +9,7 @@ const CreateClassInstanceHandler = require('./CreateClassInstanceHandler')
 const GetInstanceFieldHandler = require('./GetInstanceFieldHandler')
 const SetInstanceFieldHandler = require('./SetInstanceFieldHandler')
 const InvokeInstanceMethodHandler = require('./InvokeInstanceMethodHandler')
-const DestructReferenceHandler = require("./DestructReferenceHandler");
+const DestructReferenceHandler = require('./DestructReferenceHandler')
 const CastHandler = require('./CastingHandler')
 const InvokeGlobalMethodHandler = require('./InvokeGlobalMethodHandler')
 const ArrayGetItemHandler = require('./ArrayGetItemHandler')
@@ -25,9 +20,12 @@ const ArrayHandler = require('./ArrayHandler')
 const EnableNamespaceHandler = require('./EnableNamespaceHandler')
 const EnableTypeHandler = require('./EnableTypeHandler')
 
+const { CommandType, Command, ExceptionSerializer } = require('../../..')
+const ReferencesCache = require('../referenceCache/ReferencesCache')
+const InvokeStandaloneMethodHandler = require('./InvokeStandaloneMethodHandler')
 
 function isResponseSimpleType(response) {
-    let type = typeof (response)
+    let type = typeof response
     return ['string', 'boolean', 'number'].includes(type)
 }
 
@@ -35,7 +33,6 @@ function isResponseNull(response) {
     return response === null
 }
 
-
 const handlers = {
     [CommandType.Value]: ValueHandler,
     [CommandType.LoadLibrary]: LoadLibraryHandler,
@@ -49,6 +46,7 @@ const handlers = {
     [CommandType.GetInstanceField]: GetInstanceFieldHandler,
     [CommandType.SetInstanceField]: SetInstanceFieldHandler,
     [CommandType.InvokeInstanceMethod]: InvokeInstanceMethodHandler,
+    [CommandType.InvokeStandaloneMethod]: InvokeStandaloneMethodHandler,
     [CommandType.InvokeGlobalMethod]: InvokeGlobalMethodHandler,
     [CommandType.DestructReference]: DestructReferenceHandler,
     [CommandType.ArrayGetItem]: ArrayGetItemHandler,
@@ -57,9 +55,13 @@ const handlers = {
     [CommandType.ArraySetItem]: ArraySetItemHandler,
     [CommandType.Array]: ArrayHandler,
     [CommandType.EnableNamespace]: EnableNamespaceHandler,
-    [CommandType.EnableType]: EnableTypeHandler
+    [CommandType.EnableType]: EnableTypeHandler,
 }
 
+Object.keys(handlers).forEach((commandTypeHandler) => {
+    handlers[commandTypeHandler].handlers = handlers
+})
+
 class Handler {
     handleCommand(command) {
         try {
@@ -78,7 +80,7 @@ class Handler {
         if (isResponseNull(response) || isResponseSimpleType(response)) {
             return Command.createResponse(response, runtimeName)
         } else {
-            let cache = ReferenceCache.getInstance()
+            let cache = ReferencesCache.getInstance()
             let uuid = cache.cacheReference(response)
             return Command.createReference(uuid, runtimeName)
         }
@@ -87,4 +89,3 @@ class Handler {
 
 module.exports.Handler = Handler
 module.exports.handlers = handlers
-

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

@@ -0,0 +1,43 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class InvokeGlobalMethodHandler extends AbstractHandler {
+    requiredParametersCount = 1
+
+    constructor() {
+        super()
+    }
+
+    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('.')
+            let methodToInvoke
+            for (let i = 0; i < splitted.length; i++) {
+                methodToInvoke = !methodToInvoke ? global[splitted[i]] : methodToInvoke[splitted[i]]
+            }
+            if (typeof methodToInvoke === 'undefined') {
+                let methods = Object.getOwnPropertyNames(global).filter(function (property) {
+                    return typeof global[property] === 'function'
+                })
+                let message = `Method ${payload[0]} not found in global. Available methods:\n`
+                methods.forEach((methodIter) => {
+                    message += `${methodIter}\n`
+                })
+                throw new Error(message)
+            }
+            if (payload.length > 1) {
+                const args = payload.slice(1)
+                return methodToInvoke(args)
+            } else {
+                return methodToInvoke()
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new InvokeGlobalMethodHandler()

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

@@ -0,0 +1,38 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class InvokeInstanceMethodHandler extends AbstractHandler {
+    requiredParametersCount = 2
+
+    constructor() {
+        super()
+    }
+
+    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)
+            let method = instance[methodName]
+            if (typeof method === 'undefined') {
+                let methods = Object.getOwnPropertyNames(instance.__proto__).filter(function (property) {
+                    return typeof instance.__proto__[property] === 'function'
+                })
+                let message = `Method ${methodName} not found in object. Available methods:\n`
+                methods.forEach((methodIter) => {
+                    message += `${methodIter}\n`
+                })
+                throw new Error(message)
+            } else {
+                return Reflect.apply(method, instance, args)
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new InvokeInstanceMethodHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/InvokeStandaloneMethodHandler.js

@@ -0,0 +1,56 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class InvokeStandaloneMethodHandler extends AbstractHandler {
+    requiredParametersCount = 2
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Invoke standalone Method parameters mismatch')
+            }
+
+            const { payload } = command
+            const type = payload[0]
+            const methodName = payload[1]
+            const args = payload.slice(2)
+
+            if (typeof type === 'function') {
+                // assuming that function is exported as single (default)
+                return Reflect.apply(type, undefined, args)
+            }
+
+            if (typeof type === 'object') {
+                // assuming that function inside of multiple exports
+                const method = type[methodName]
+
+                if (typeof method === 'function') {
+                    return Reflect.apply(method, undefined, args)
+                }
+                return this.throwError(type, methodName)
+            } else {
+                throw new Error(`Function ${methodName} not found in libary.`)
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+
+    throwError(type, methodName) {
+        const methods = Object.getOwnPropertyNames(type).filter(
+            (property) => typeof type[property] === 'function'
+        )
+
+        let message = `Function ${methodName} not found in libary. Available standalone methods:\n`
+        methods.forEach((methodIter) => {
+            message += `${methodIter}\n`
+        })
+
+        throw new Error(message)
+    }
+}
+
+module.exports = new InvokeStandaloneMethodHandler()

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

@@ -0,0 +1,38 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class InvokeStaticMethodHandler extends AbstractHandler {
+    requiredParametersCount = 2
+
+    constructor() {
+        super()
+    }
+
+    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)
+            let method = type[methodName]
+            if (typeof method === 'undefined') {
+                let methods = Object.getOwnPropertyNames(type).filter(function (property) {
+                    return typeof type[property] === 'function'
+                })
+                let message = `Method ${methodName} not found in class. Available methods:\n`
+                methods.forEach((methodIter) => {
+                    message += `${methodIter}\n`
+                })
+                throw new Error(message)
+            } else {
+                return Reflect.apply(method, undefined, args)
+            }
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new InvokeStaticMethodHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/handler/LoadLibraryHandler.js

@@ -2,6 +2,7 @@ const AbstractHandler = require('./AbstractHandler')
 
 class LoadLibraryHandler extends AbstractHandler {
     requiredParametersCount = 1
+    static loadedLibraries = []
 
     constructor() {
         super()
@@ -9,9 +10,9 @@ class LoadLibraryHandler extends AbstractHandler {
 
     process(command) {
         if (command.payload.length < this.requiredParametersCount) {
-            throw new Error("Load Library parameters mismatch")
+            throw new Error('Load Library parameters mismatch')
         }
-        let {payload} = command
+        let { payload } = command
         let [lib] = payload
         let pathArray = lib.split(/[/\\]/)
         let libraryName = pathArray.length > 1 ? pathArray[pathArray.length - 1] : pathArray[0]
@@ -21,6 +22,8 @@ class LoadLibraryHandler extends AbstractHandler {
 
         try {
             moduleExports = require(lib)
+            LoadLibraryHandler.loadedLibraries.push(lib)
+            // eslint-disable-next-line no-unused-vars
         } catch (error) {
             try {
                 moduleExports = require(`${process.cwd()}/${lib}`)
@@ -36,6 +39,10 @@ class LoadLibraryHandler extends AbstractHandler {
         }
         return 0
     }
+
+    getLoadedLibraries() {
+        return LoadLibraryHandler.loadedLibraries
+    }
 }
 
 module.exports = new LoadLibraryHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/ResolveReferenceHandler.js

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

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/SetGlobalStaticFieldHandler.js

@@ -0,0 +1,38 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class SetGlobalStaticFieldHandler extends AbstractHandler {
+    requiredParametersCount = 2
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Set gloabal static field parameters mismatch')
+            }
+            const { payload } = command
+            const splitted = payload[0].split('.')
+            const value = payload[1]
+            let fieldToSet
+
+            for (let i = 0; i < splitted.length; i++) {
+                if (typeof (fieldToSet ? fieldToSet[splitted[i]] : global[splitted[i]]) === 'undefined') {
+                    let fields = Object.keys(fieldToSet ? fieldToSet : global)
+                    let message = `Field ${splitted[i]} not found in object. Available fields:\n`
+                    fields.forEach((fieldIter) => {
+                        message += `${fieldIter}\n`
+                    })
+                    throw new Error(message)
+                }
+                fieldToSet = !fieldToSet ? global[splitted[i]] : fieldToSet[splitted[i]]
+            }
+            fieldToSet = value
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new SetGlobalStaticFieldHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/SetInstanceFieldHandler.js

@@ -0,0 +1,35 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class SetInstanceFieldHandler extends AbstractHandler {
+    requiredParametersCount = 3
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Set Instance Field parameters mismatch')
+            }
+            const { payload } = command
+            let instance = payload[0]
+            let field = payload[1]
+            let value = payload[2]
+            if (typeof instance[field] === 'undefined') {
+                let fields = Object.keys(instance)
+                let message = `Field ${field} not found in object. Available fields:\n`
+                fields.forEach((fieldIter) => {
+                    message += `${fieldIter}\n`
+                })
+                throw new Error(message)
+            }
+            instance[field] = value
+            return 0
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new SetInstanceFieldHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/lib/core/handler/SetStaticFieldHandler.js

@@ -0,0 +1,33 @@
+const AbstractHandler = require('./AbstractHandler')
+
+class SetStaticFieldHandler extends AbstractHandler {
+    requiredParametersCount = 3
+
+    constructor() {
+        super()
+    }
+
+    process(command) {
+        try {
+            if (command.payload.length < this.requiredParametersCount) {
+                throw new Error('Set static field parameters mismatch')
+            }
+            const { payload } = command
+            let [obj, field, value] = payload
+            if (typeof obj[field] === 'undefined') {
+                let fields = Object.keys(obj)
+                let message = `Field ${field} not found in class ${obj.constructor.name}. Available fields:\n`
+                fields.forEach((fieldIter) => {
+                    message += `${fieldIter}\n`
+                })
+                throw new Error(message)
+            }
+            obj[field] = value
+            return 0
+        } catch (error) {
+            throw this.process_stack_trace(error, this.constructor.name)
+        }
+    }
+}
+
+module.exports = new SetStaticFieldHandler()

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/handler/ValueHandler.js

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

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

@@ -0,0 +1,142 @@
+const ConnectionType = require('../../utils/ConnectionType')
+const RuntimeName = require('../../utils/RuntimeName')
+const CommandDeserializer = require('../protocol/CommandDeserializer')
+const CommandSerializer = require('../protocol/CommandSerializer')
+
+/** @typedef {import('../../../../core/lib/declarations').WsConnectionData} WsConnectionData */
+
+let _Receiver
+let _Transmitter
+let _TransmitterWebsocket
+
+class Interpreter {
+    handler
+    /**
+     *
+     * @param {Command} command
+     * @param {IConnectionData} connectionData
+     * @returns
+     */
+    async executeAsync(command, connectionData) {
+        try {
+            let messageByteArray = new CommandSerializer().serialize(command, connectionData)
+            let responseByteArray
+
+            if (
+                command.runtimeName === RuntimeName.Nodejs &&
+                connectionData.connectionType === ConnectionType.IN_MEMORY
+            ) {
+                // lazy receiver loading
+                if (!_Receiver) {
+                    _Receiver = require(require.resolve('../receiver/Receiver'))
+                }
+                responseByteArray = _Receiver.sendCommand(messageByteArray)
+            } else if (
+                command.runtimeName === RuntimeName.Nodejs &&
+                connectionData.connectionType === ConnectionType.WEB_SOCKET
+            ) {
+                try {
+                    // lazy transmitter websocket loading
+                    if (!_TransmitterWebsocket) {
+                        _TransmitterWebsocket = require('../transmitter/TransmitterWebsocket')
+                    }
+                    const promise = _TransmitterWebsocket.sendCommand(messageByteArray, connectionData)
+                    return promise
+                        .then((_response) => {
+                            if (_response) {
+                                const command = new CommandDeserializer(_response).deserialize()
+                                return command
+                            }
+                        })
+                        .catch((error) => {
+                            throw error
+                        })
+                } catch (error) {
+                    console.log(error)
+                }
+            } else {
+                // lazy transmitter loading
+                if (!_Transmitter) {
+                    _Transmitter = require(require.resolve('../transmitter/Transmitter'))
+                }
+                responseByteArray = await _Transmitter.sendCommand(messageByteArray)
+            }
+            return new CommandDeserializer(responseByteArray).deserialize()
+            // eslint-disable-next-line no-unused-vars
+        } catch (error) {
+            // TODO: handle error exception log?
+        }
+    }
+
+    /**
+     *
+     * @param {Command} command
+     * @param {WsConnectionData} connectionData
+     * @returns {Promise<Command>}
+     */
+    execute(command, connectionData) {
+        try {
+            let messageByteArray = new CommandSerializer().serialize(command, connectionData)
+            let responseByteArray
+
+            if (
+                command.runtimeName === RuntimeName.Nodejs &&
+                connectionData.connectionType === ConnectionType.IN_MEMORY
+            ) {
+                // lazy receiver loading
+                if (!_Receiver) {
+                    _Receiver = require(require.resolve('../receiver/Receiver'))
+                }
+                responseByteArray = _Receiver.sendCommand(messageByteArray)
+            } else if (
+                command.runtimeName === RuntimeName.Nodejs &&
+                connectionData.connectionType === ConnectionType.WEB_SOCKET
+            ) {
+                // lazy transmitter websocket loading
+                if (!_TransmitterWebsocket) {
+                    _TransmitterWebsocket = require(require.resolve('../transmitter/TransmitterWebsocket'))
+                }
+                const promise = _TransmitterWebsocket.sendCommand(messageByteArray, connectionData)
+                return promise
+                    .then((_response) => {
+                        if (_response) {
+                            const command = new CommandDeserializer(_response).deserialize()
+                            return command
+                        }
+                    })
+                    .catch((error) => {
+                        throw error
+                    })
+            } else {
+                // lazy transmitter loading
+                if (!_Transmitter) {
+                    _Transmitter = require(require.resolve('../transmitter/Transmitter'))
+                }
+                responseByteArray = _Transmitter.sendCommand(messageByteArray)
+            }
+            return new CommandDeserializer(responseByteArray).deserialize()
+            // eslint-disable-next-line no-unused-vars
+        } catch (error) {
+            // TODO: handle error exception log?
+        }
+    }
+
+    /**
+     *
+     * @param {number[]} messageByteArray
+     * @returns {Command}
+     */
+    process(messageByteArray) {
+        if (!this.handler) {
+            const baseHandler = require(require.resolve('../handler/Handler'))
+            if (baseHandler) {
+                const { Handler } = baseHandler
+                this.handler = new Handler()
+            }
+        }
+        const receivedCommand = new CommandDeserializer(messageByteArray).deserialize()
+        return this.handler.handleCommand(receivedCommand)
+    }
+}
+
+module.exports = Interpreter

data/lib/javonet-ruby-sdk/Binaries/Nodejs/{core → lib/core}/namespaceCache/NamespaceCache.js

@@ -1,39 +1,39 @@
 class NamespaceCache {
-    static _instance = null;
-    namespaceCache = [];
+    static _instance = null
+    namespaceCache = []
 
     constructor() {
         if (NamespaceCache._instance === null) {
-            NamespaceCache._instance = this;
+            NamespaceCache._instance = this
         }
-        return NamespaceCache._instance;
+        return NamespaceCache._instance
     }
 
     cacheNamespace(namespaceRegex) {
-        this.namespaceCache.push(namespaceRegex);
+        this.namespaceCache.push(namespaceRegex)
     }
 
     isNamespaceCacheEmpty() {
-        return this.namespaceCache.length === 0;
+        return this.namespaceCache.length === 0
     }
 
     isTypeAllowed(typeToCheck) {
         for (let pattern of this.namespaceCache) {
             if (new RegExp(pattern).test(typeToCheck.constructor.name)) {
-                return true;
+                return true
             }
         }
-        return false;
+        return false
     }
 
     getCachedNamespaces() {
-        return this.namespaceCache;
+        return this.namespaceCache
     }
 
     clearCache() {
-        this.namespaceCache = [];
-        return 0;
+        this.namespaceCache = []
+        return 0
     }
 }
 
-module.exports = NamespaceCache;
+module.exports = NamespaceCache