javonet-ruby-sdk 2.5.8 → 2.5.10

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

@@ -0,0 +1,157 @@
+// eslint-disable-next-line no-unused-vars
+const { Interpreter, Command, CommandType, InMemoryConnectionData, DelegatesCache } = require('../../..')
+const AbstractHandler = require('./AbstractHandler')
+
+/**
+ * PassDelegateHandler class responsible for processing a command to create a delegate.
+ */
+class PassDelegateHandler extends AbstractHandler {
+    constructor() {
+        super()
+        /**
+         * Minimum required parameters count for the command.
+         * @type {number}
+         */
+        this.requiredParametersCount = 1
+        this.interpreter = new Interpreter()
+    }
+
+    /**
+     * Processes the given command to create and compile a delegate.
+     * @param {Command} command - The command to process.
+     * @returns {Function} The compiled delegate function.
+     */
+    process(command) {
+        this.validateCommand(command)
+
+        const delegateGuid = command.payload[0]
+        const delegate = DelegatesCache.getDelegate(delegateGuid)
+
+        return delegate
+    }
+
+    /**
+     * Validates the command to ensure it has enough parameters.
+     * @param {Command} command - The command to validate.
+     */
+    validateCommand(command) {
+        if (command.payload.length < this.requiredParametersCount) {
+            throw new Error('PassDelegateHandler parameters mismatch')
+        }
+    }
+
+    /**
+     * Retrieves the arguments from the command payload.
+     * @param {Command} command - The command containing the payload.
+     * @returns {Array} The extracted arguments.
+     */
+    getArguments(command) {
+        return command.payload.length > 2 ? command.payload.slice(2) : []
+    }
+
+    /**
+     * Extracts argument types from the arguments array.
+     * @param {Array} args - The arguments array.
+     * @returns {Array} The argument types.
+     */
+    getArgumentTypes(args) {
+        return args.slice(0, -1).map((arg) => arg.constructor)
+    }
+
+    /**
+     * Retrieves the return type from the arguments array.
+     * @param {Array} args - The arguments array.
+     * @returns {Function} The return type.
+     */
+    getReturnType(args) {
+        return args[args.length - 1].constructor
+    }
+
+    /**
+     * Creates parameter expressions from argument types.
+     * @param {Array} argsTypes - The argument types.
+     * @returns {Array} The parameter expressions.
+     */
+    createParameters(argsTypes) {
+        return argsTypes.map((type, index) => ({ name: `arg${index}`, type }))
+    }
+
+    /**
+     * Creates an array of arguments for the delegate.
+     * @param {string} delegateGuid - The delegate identifier.
+     * @param {Array} parameters - The parameter expressions.
+     * @returns {Array} The arguments array.
+     */
+    createArgsArray(delegateGuid, parameters) {
+        return [delegateGuid, ...parameters.map((param) => param.name)]
+    }
+
+    /**
+     * Creates a command expression.
+     * @param {string} callingRuntimeName - The runtime name.
+     * @param {Array} payload - The arguments array.
+     * @returns {Object} The command object.
+     */
+    createCommand(callingRuntimeName, payload) {
+        return {
+            runtimeName: callingRuntimeName,
+            type: CommandType.InvokeDelegate,
+            payload,
+        }
+    }
+
+    /**
+     * Creates a method call to execute the command.
+     * @param {Command} command - The command object.
+     * @returns {Object} The response object.
+     */
+    createExecuteCall(command) {
+        return this.interpreter.execute(command, new InMemoryConnectionData())
+    }
+
+    /**
+     * Retrieves the response payload from the execution call.
+     * @param {Object} executeCall - The execution call.
+     * @returns {Array} The response payload.
+     */
+    getResponse(executeCall) {
+        return executeCall.payload
+    }
+
+    /**
+     * Converts the first element of the response to the return type.
+     * @param {Array} response - The response payload.
+     * @param {Function} returnType - The return type.
+     * @returns {*} The converted first element.
+     */
+    convertFirstElement(response, returnType) {
+        return returnType(response[0])
+    }
+
+    /**
+     * Creates a block of expressions for the delegate.
+     * @param {Function} returnType - The return type.
+     * @param {*} convertedFirstElement - The converted first element.
+     * @returns {Object} The block expression.
+     */
+    createBlock(returnType, convertedFirstElement) {
+        return { returnType, body: convertedFirstElement }
+    }
+
+    /**
+     * Creates a delegate type.
+     * @param {Array} parameters - The parameter expressions.
+     * @param {Function} returnType - The return type.
+     * @returns {Function} The delegate type.
+     */
+    createDelegateType(parameters, returnType) {
+        return (...args) => {
+            if (args.length !== parameters.length) {
+                throw new Error('Invalid argument count.')
+            }
+            return returnType
+        }
+    }
+}
+
+module.exports = new PassDelegateHandler()

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